diff --git a/.gitattributes b/.gitattributes index 0bdd5738c8..c4bdb1fed4 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,3 +1,4 @@ *.binary filter=lfs diff=lfs merge=lfs -crlf data/lm/trie filter=lfs diff=lfs merge=lfs -crlf data/lm/vocab.txt filter=lfs diff=lfs merge=lfs -text +data/lm/trie.ctcdecode filter=lfs diff=lfs merge=lfs -text diff --git a/DeepSpeech.py b/DeepSpeech.py index efda6a0b24..832813b623 100755 --- a/DeepSpeech.py +++ b/DeepSpeech.py @@ -1770,6 +1770,9 @@ def create_inference_graph(batch_size=1, n_steps=16, use_new_decoder=False): n_steps=n_steps, previous_state=previous_state) + # Apply softmax for CTC decoder + logits = tf.nn.softmax(logits) + new_state_c, new_state_h = layers['rnn_output_state'] # Initial zero state diff --git a/data/lm/README.md b/data/lm/README.md index 46db2979df..8883203c91 100644 --- a/data/lm/README.md +++ b/data/lm/README.md @@ -38,9 +38,8 @@ binary_path = '/tmp/lm.binary' os.remove(lm_path) ``` -The trie was then generated from the list of unique words in the corpus (data/lm/vocab.txt): +The trie was then generated from the vocabulary of the language model: ```bash -tr -s '[[:space:]]' '\n' < /tmp/lower.txt | sort -u > /tmp/vocab.txt -./generate_trie ../data/alphabet.txt /tmp/lm.binary /tmp/vocab.txt /tmp/trie +./generate_trie ../data/alphabet.txt /tmp/lm.binary /tmp/trie ``` diff --git a/data/lm/trie.ctcdecode b/data/lm/trie.ctcdecode new file mode 100644 index 0000000000..a937a2267f --- /dev/null +++ b/data/lm/trie.ctcdecode @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a5324f06b27c7b4ef88dd2c8bc3d05d4c718db219c2e007f59061a30c9ac7afa +size 21627983 diff --git a/data/smoke_test/vocab.trie.ctcdecode b/data/smoke_test/vocab.trie.ctcdecode new file mode 100644 index 0000000000..3a5d637ff2 Binary files /dev/null and b/data/smoke_test/vocab.trie.ctcdecode differ diff --git a/native_client/BUILD b/native_client/BUILD index f953aa35c1..5e21240657 100644 --- a/native_client/BUILD +++ b/native_client/BUILD @@ -10,13 +10,40 @@ genrule( tools = [":ds_git_version.sh"] ) +KENLM_SOURCES = glob(["kenlm/lm/*.cc", "kenlm/util/*.cc", "kenlm/util/double-conversion/*.cc", + "kenlm/lm/*.hh", "kenlm/util/*.hh", "kenlm/util/double-conversion/*.h"], + exclude = ["kenlm/*/*test.cc", "kenlm/*/*main.cc"]) + glob(["boost_locale/**/*.hpp"]) + +KENLM_INCLUDES = [ + "kenlm", + "boost_locale" +] + +DECODER_SOURCES = glob([ + "ctcdecode/*.h", + "ctcdecode/*.cpp", + "ctcdecode/third_party/openfst-1.6.7/src/lib/*.cc" +]) + KENLM_SOURCES + +DECODER_INCLUDES = [ + ".", + "ctcdecode/third_party/openfst-1.6.7/src/include", + "ctcdecode/third_party/ThreadPool" +] + KENLM_INCLUDES + +LINUX_LINKOPTS = [ + "-ldl", + "-pthread", + "-Wl,-Bsymbolic", + "-Wl,-Bsymbolic-functions", + "-Wl,-export-dynamic" +] + tf_cc_shared_object( name = "libdeepspeech.so", srcs = ["deepspeech.cc", "deepspeech.h", "alphabet.h", - "beam_search.h", - "trie_node.h", "c_speech_features/c_speech_features.cpp", "kiss_fft130/kiss_fft.c", "kiss_fft130/tools/kiss_fftr.c", @@ -26,25 +53,19 @@ tf_cc_shared_object( "kiss_fft130/_kiss_fft_guts.h", "kiss_fft130/tools/kiss_fftr.h", "ds_version.h"] + - glob(["kenlm/lm/*.cc", "kenlm/util/*.cc", "kenlm/util/double-conversion/*.cc", - "kenlm/lm/*.hh", "kenlm/util/*.hh", "kenlm/util/double-conversion/*.h"], - exclude = ["kenlm/*/*test.cc", "kenlm/*/*main.cc"]) + - glob(["boost_locale/**/*.hpp"]), + DECODER_SOURCES, # -Wno-sign-compare to silent a lot of warnings from tensorflow itself, # which makes it harder to see our own warnings copts = ["-Wno-sign-compare", "-fvisibility=hidden"], linkopts = select({ "//tensorflow:darwin": [], - "//conditions:default": [ - "-Wl,-Bsymbolic", - "-Wl,-Bsymbolic-functions", - "-Wl,-export-dynamic", - ], + "//tensorflow:linux_x86_64": LINUX_LINKOPTS, + "//tensorflow:rpi3": LINUX_LINKOPTS + ["-l:libstdc++.a"], + "//tensorflow:rpi3-armv8": LINUX_LINKOPTS + ["-l:libstdc++.a"], }), deps = [ "//tensorflow/core:core_cpu", "//tensorflow/core:direct_session", - "//tensorflow/core/util/ctc", "//third_party/eigen3", #"//tensorflow/core:all_kernels", ### => Trying to be more fine-grained @@ -54,6 +75,7 @@ tf_cc_shared_object( "//tensorflow/core/kernels:constant_op", # Const "//tensorflow/core/kernels:immutable_constant_op", # ImmutableConst "//tensorflow/core/kernels:identity_op", # Identity + "//tensorflow/core/kernels:softmax_op", # Softmax "//tensorflow/core/kernels:transpose_op", # Transpose "//tensorflow/core/kernels:reshape_op", # Reshape "//tensorflow/core/kernels:shape_ops", # Shape @@ -76,7 +98,7 @@ tf_cc_shared_object( ] + if_cuda([ "//tensorflow/core:core", ]), - includes = ["kenlm", "boost_locale", "c_speech_features", "kiss_fft130"], + includes = ["c_speech_features", "kiss_fft130"] + DECODER_INCLUDES, defines = ["KENLM_MAX_ORDER=6"], ) @@ -88,11 +110,8 @@ tf_cc_shared_object( "alphabet.h", "trie_node.h" ] + - glob(["kenlm/lm/*.cc", "kenlm/util/*.cc", "kenlm/util/double-conversion/*.cc", - "kenlm/lm/*.hh", "kenlm/util/*.hh", "kenlm/util/double-conversion/*.h"], - exclude = ["kenlm/*/*test.cc", "kenlm/*/*main.cc"]) + - glob(["boost_locale/**/*.hpp"]), - includes = ["kenlm", "boost_locale"], + KENLM_SOURCES, + includes = KENLM_INCLUDES, copts = ["-std=c++11"], defines = ["KENLM_MAX_ORDER=6"], deps = ["//tensorflow/core:framework_headers_lib", @@ -105,16 +124,11 @@ cc_binary( name = "generate_trie", srcs = [ "generate_trie.cpp", - "trie_node.h", "alphabet.h", - ] + - glob(["kenlm/lm/*.cc", "kenlm/util/*.cc", "kenlm/util/double-conversion/*.cc", - "kenlm/lm/*.hh", "kenlm/util/*.hh", "kenlm/util/double-conversion/*.h"], - exclude = ["kenlm/*/*test.cc", "kenlm/*/*main.cc"]) + - glob(["boost_locale/**/*.hpp"]), - includes = ["kenlm", "boost_locale"], + ] + DECODER_SOURCES, + includes = DECODER_INCLUDES, copts = ["-std=c++11"], - linkopts = ["-lm"], + linkopts = ["-lm", "-ldl", "-pthread"], defines = ["KENLM_MAX_ORDER=6"], ) @@ -122,15 +136,10 @@ cc_binary( name = "trie_load", srcs = [ "trie_load.cc", - "trie_node.h", "alphabet.h", - ] + - glob(["kenlm/lm/*.cc", "kenlm/util/*.cc", "kenlm/util/double-conversion/*.cc", - "kenlm/lm/*.hh", "kenlm/util/*.hh", "kenlm/util/double-conversion/*.h"], - exclude = ["kenlm/*/*test.cc", "kenlm/*/*main.cc"]) + - glob(["boost_locale/**/*.hpp"]), - includes = ["kenlm", "boost_locale"], + ] + DECODER_SOURCES, + includes = DECODER_INCLUDES, copts = ["-std=c++11"], - linkopts = ["-lm"], + linkopts = ["-lm", "-ldl", "-pthread"], defines = ["KENLM_MAX_ORDER=6"], ) diff --git a/native_client/alphabet.h b/native_client/alphabet.h index cf34eebe68..70239acb49 100644 --- a/native_client/alphabet.h +++ b/native_client/alphabet.h @@ -6,6 +6,7 @@ #include #include #include +#include /* * Loads a text file describing a mapping of labels to strings, one string per @@ -17,13 +18,18 @@ class Alphabet { Alphabet(const char *config_file) { std::ifstream in(config_file, std::ios::in); unsigned int label = 0; + space_label_ = -2; for (std::string line; std::getline(in, line);) { if (line.size() == 2 && line[0] == '\\' && line[1] == '#') { line = '#'; } else if (line[0] == '#') { continue; } - label_to_str_[label] = line; + //TODO: we should probably do something more i18n-aware here + if (line == " ") { + space_label_ = label; + } + label_to_str_.push_back(line); str_to_label_[line] = label; ++label; } @@ -33,13 +39,7 @@ class Alphabet { const std::string& StringFromLabel(unsigned int label) const { assert(label < size_); - auto it = label_to_str_.find(label); - if (it != label_to_str_.end()) { - return it->second; - } else { - // unreachable due to assert above - abort(); - } + return label_to_str_[label]; } unsigned int LabelFromString(const std::string& string) const { @@ -52,19 +52,31 @@ class Alphabet { } } - size_t GetSize() { + size_t GetSize() const { return size_; } bool IsSpace(unsigned int label) const { - //TODO: we should probably do something more i18n-aware here - const std::string& str = StringFromLabel(label); - return str.size() == 1 && str[0] == ' '; + return label == space_label_; + } + + unsigned int GetSpaceLabel() const { + return space_label_; + } + + template + std::string LabelsToString(const std::vector& input) const { + std::string word; + for (auto ind : input) { + word += StringFromLabel(ind); + } + return word; } private: size_t size_; - std::unordered_map label_to_str_; + unsigned int space_label_; + std::vector label_to_str_; std::unordered_map str_to_label_; }; diff --git a/native_client/args.h b/native_client/args.h index 27899c182a..e6d2349d10 100644 --- a/native_client/args.h +++ b/native_client/args.h @@ -16,6 +16,8 @@ char* trie = NULL; char* audio = NULL; +bool load_without_trie = false; + bool show_times = false; bool has_versions = false; @@ -48,6 +50,7 @@ bool ProcessArgs(int argc, char** argv) {"lm", required_argument, nullptr, 'l'}, {"trie", required_argument, nullptr, 'r'}, {"audio", required_argument, nullptr, 'w'}, + {"run_very_slowly_without_trie_I_really_know_what_Im_doing", no_argument, nullptr, 999}, {"t", no_argument, nullptr, 't'}, {"help", no_argument, nullptr, 'h'}, {"version", no_argument, nullptr, 'v'}, @@ -64,23 +67,27 @@ bool ProcessArgs(int argc, char** argv) switch (opt) { case 'm': - model = optarg; + model = optarg; break; case 'a': - alphabet = optarg; + alphabet = optarg; break; case 'l': - lm = optarg; + lm = optarg; break; case 'r': - trie = optarg; + trie = optarg; break; case 'w': - audio = optarg; + audio = optarg; + break; + + case 999: + load_without_trie = true; break; case 't': diff --git a/native_client/client.cc b/native_client/client.cc index f622014005..5826e8758e 100644 --- a/native_client/client.cc +++ b/native_client/client.cc @@ -200,7 +200,7 @@ main(int argc, char **argv) return 1; } - if (lm && trie) { + if (lm && (trie || load_without_trie)) { int status = DS_EnableDecoderWithLM(ctx, alphabet, lm, diff --git a/native_client/ctcdecode/LICENSE b/native_client/ctcdecode/LICENSE new file mode 100644 index 0000000000..4faebd01c1 --- /dev/null +++ b/native_client/ctcdecode/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2017 Ryan Leary + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + diff --git a/native_client/ctcdecode/README.mozilla b/native_client/ctcdecode/README.mozilla new file mode 100644 index 0000000000..badd6e34ad --- /dev/null +++ b/native_client/ctcdecode/README.mozilla @@ -0,0 +1,2 @@ +Originally imported from https://github.com/parlance/ctcdecode, commit 140b45860cec6671fb0bf6dbb675073241c0f9b0 + diff --git a/native_client/ctcdecode/ctc_beam_search_decoder.cpp b/native_client/ctcdecode/ctc_beam_search_decoder.cpp new file mode 100644 index 0000000000..2df2eb1020 --- /dev/null +++ b/native_client/ctcdecode/ctc_beam_search_decoder.cpp @@ -0,0 +1,214 @@ +#include "ctc_beam_search_decoder.h" + +#include +#include +#include +#include +#include +#include + +#include "decoder_utils.h" +#include "ThreadPool.h" +#include "fst/fstlib.h" +#include "path_trie.h" + +using FSTMATCH = fst::SortedMatcher; + +std::vector> ctc_beam_search_decoder( + const std::vector> &probs_seq, + const Alphabet &alphabet, + size_t beam_size, + double cutoff_prob, + size_t cutoff_top_n, + Scorer *ext_scorer) { + // dimension check + size_t num_time_steps = probs_seq.size(); + for (size_t i = 0; i < num_time_steps; ++i) { + VALID_CHECK_EQ(probs_seq[i].size(), + alphabet.GetSize()+1, + "The shape of probs_seq does not match with " + "the shape of the vocabulary"); + } + + // assign special ids + int space_id = alphabet.GetSpaceLabel(); + int blank_id = alphabet.GetSize(); + + // init prefixes' root + PathTrie root; + root.score = root.log_prob_b_prev = 0.0; + std::vector prefixes; + prefixes.push_back(&root); + + if (ext_scorer != nullptr && !ext_scorer->is_character_based()) { + auto dict_ptr = ext_scorer->dictionary->Copy(true); + root.set_dictionary(dict_ptr); + auto matcher = std::make_shared(*dict_ptr, fst::MATCH_INPUT); + root.set_matcher(matcher); + } + + // prefix search over time + for (size_t time_step = 0; time_step < num_time_steps; ++time_step) { + auto &prob = probs_seq[time_step]; + + float min_cutoff = -NUM_FLT_INF; + bool full_beam = false; + if (ext_scorer != nullptr) { + size_t num_prefixes = std::min(prefixes.size(), beam_size); + std::sort( + prefixes.begin(), prefixes.begin() + num_prefixes, prefix_compare); + min_cutoff = prefixes[num_prefixes - 1]->score + + std::log(prob[blank_id]) - std::max(0.0, ext_scorer->beta); + full_beam = (num_prefixes == beam_size); + } + + std::vector> log_prob_idx = + get_pruned_log_probs(prob, cutoff_prob, cutoff_top_n); + // loop over chars + for (size_t index = 0; index < log_prob_idx.size(); index++) { + auto c = log_prob_idx[index].first; + auto log_prob_c = log_prob_idx[index].second; + + for (size_t i = 0; i < prefixes.size() && i < beam_size; ++i) { + auto prefix = prefixes[i]; + if (full_beam && log_prob_c + prefix->score < min_cutoff) { + break; + } + // blank + if (c == blank_id) { + prefix->log_prob_b_cur = + log_sum_exp(prefix->log_prob_b_cur, log_prob_c + prefix->score); + continue; + } + // repeated character + if (c == prefix->character) { + prefix->log_prob_nb_cur = log_sum_exp( + prefix->log_prob_nb_cur, log_prob_c + prefix->log_prob_nb_prev); + } + // get new prefix + auto prefix_new = prefix->get_path_trie(c, time_step); + + if (prefix_new != nullptr) { + float log_p = -NUM_FLT_INF; + + if (c == prefix->character && + prefix->log_prob_b_prev > -NUM_FLT_INF) { + log_p = log_prob_c + prefix->log_prob_b_prev; + } else if (c != prefix->character) { + log_p = log_prob_c + prefix->score; + } + + // language model scoring + if (ext_scorer != nullptr && + (c == space_id || ext_scorer->is_character_based())) { + PathTrie *prefix_to_score = nullptr; + // skip scoring the space + if (ext_scorer->is_character_based()) { + prefix_to_score = prefix_new; + } else { + prefix_to_score = prefix; + } + + float score = 0.0; + std::vector ngram; + ngram = ext_scorer->make_ngram(prefix_to_score); + score = ext_scorer->get_log_cond_prob(ngram) * ext_scorer->alpha; + log_p += score; + log_p += ext_scorer->beta; + } + prefix_new->log_prob_nb_cur = + log_sum_exp(prefix_new->log_prob_nb_cur, log_p); + } + } // end of loop over prefix + } // end of loop over vocabulary + + + prefixes.clear(); + // update log probs + root.iterate_to_vec(prefixes); + + // only preserve top beam_size prefixes + if (prefixes.size() >= beam_size) { + std::nth_element(prefixes.begin(), + prefixes.begin() + beam_size, + prefixes.end(), + prefix_compare); + for (size_t i = beam_size; i < prefixes.size(); ++i) { + prefixes[i]->remove(); + } + } + } // end of loop over time + + // score the last word of each prefix that doesn't end with space + if (ext_scorer != nullptr && !ext_scorer->is_character_based()) { + for (size_t i = 0; i < beam_size && i < prefixes.size(); ++i) { + auto prefix = prefixes[i]; + if (!prefix->is_empty() && prefix->character != space_id) { + float score = 0.0; + std::vector ngram = ext_scorer->make_ngram(prefix); + score = ext_scorer->get_log_cond_prob(ngram) * ext_scorer->alpha; + score += ext_scorer->beta; + prefix->score += score; + } + } + } + + size_t num_prefixes = std::min(prefixes.size(), beam_size); + std::sort(prefixes.begin(), prefixes.begin() + num_prefixes, prefix_compare); + + // compute aproximate ctc score as the return score, without affecting the + // return order of decoding result. To delete when decoder gets stable. + for (size_t i = 0; i < beam_size && i < prefixes.size(); ++i) { + double approx_ctc = prefixes[i]->score; + if (ext_scorer != nullptr) { + std::vector output; + std::vector timesteps; + prefixes[i]->get_path_vec(output, timesteps); + auto prefix_length = output.size(); + auto words = ext_scorer->split_labels(output); + // remove word insert + approx_ctc = approx_ctc - prefix_length * ext_scorer->beta; + // remove language model weight: + approx_ctc -= (ext_scorer->get_sent_log_prob(words)) * ext_scorer->alpha; + } + prefixes[i]->approx_ctc = approx_ctc; + } + + return get_beam_search_result(prefixes, beam_size); +} + + +std::vector>> +ctc_beam_search_decoder_batch( + const std::vector>> &probs_split, + const Alphabet &alphabet, + size_t beam_size, + size_t num_processes, + double cutoff_prob, + size_t cutoff_top_n, + Scorer *ext_scorer) { + VALID_CHECK_GT(num_processes, 0, "num_processes must be nonnegative!"); + // thread pool + ThreadPool pool(num_processes); + // number of samples + size_t batch_size = probs_split.size(); + + // enqueue the tasks of decoding + std::vector>>> res; + for (size_t i = 0; i < batch_size; ++i) { + res.emplace_back(pool.enqueue(ctc_beam_search_decoder, + probs_split[i], + alphabet, + beam_size, + cutoff_prob, + cutoff_top_n, + ext_scorer)); + } + + // get decoding results + std::vector>> batch_results; + for (size_t i = 0; i < batch_size; ++i) { + batch_results.emplace_back(res[i].get()); + } + return batch_results; +} diff --git a/native_client/ctcdecode/ctc_beam_search_decoder.h b/native_client/ctcdecode/ctc_beam_search_decoder.h new file mode 100644 index 0000000000..5fab441e1e --- /dev/null +++ b/native_client/ctcdecode/ctc_beam_search_decoder.h @@ -0,0 +1,64 @@ +#ifndef CTC_BEAM_SEARCH_DECODER_H_ +#define CTC_BEAM_SEARCH_DECODER_H_ + +#include +#include +#include + +#include "scorer.h" +#include "output.h" +#include "alphabet.h" + +/* CTC Beam Search Decoder + + * Parameters: + * probs_seq: 2-D vector that each element is a vector of probabilities + * over vocabulary of one time step. + * vocabulary: A vector of vocabulary. + * beam_size: The width of beam search. + * cutoff_prob: Cutoff probability for pruning. + * cutoff_top_n: Cutoff number for pruning. + * ext_scorer: External scorer to evaluate a prefix, which consists of + * n-gram language model scoring and word insertion term. + * Default null, decoding the input sample without scorer. + * Return: + * A vector that each element is a pair of score and decoding result, + * in desending order. +*/ + +std::vector> ctc_beam_search_decoder( + const std::vector> &probs_seq, + const Alphabet &vocabulary, + size_t beam_size, + double cutoff_prob = 1.0, + size_t cutoff_top_n = 40, + Scorer *ext_scorer = nullptr); + +/* CTC Beam Search Decoder for batch data + + * Parameters: + * probs_seq: 3-D vector that each element is a 2-D vector that can be used + * by ctc_beam_search_decoder(). + * vocabulary: A vector of vocabulary. + * beam_size: The width of beam search. + * num_processes: Number of threads for beam search. + * cutoff_prob: Cutoff probability for pruning. + * cutoff_top_n: Cutoff number for pruning. + * ext_scorer: External scorer to evaluate a prefix, which consists of + * n-gram language model scoring and word insertion term. + * Default null, decoding the input sample without scorer. + * Return: + * A 2-D vector that each element is a vector of beam search decoding + * result for one audio sample. +*/ +std::vector>> +ctc_beam_search_decoder_batch( + const std::vector>> &probs_split, + const Alphabet &vocabulary, + size_t beam_size, + size_t num_processes, + double cutoff_prob = 1.0, + size_t cutoff_top_n = 40, + Scorer *ext_scorer = nullptr); + +#endif // CTC_BEAM_SEARCH_DECODER_H_ diff --git a/native_client/ctcdecode/decoder_utils.cpp b/native_client/ctcdecode/decoder_utils.cpp new file mode 100644 index 0000000000..375a06fe62 --- /dev/null +++ b/native_client/ctcdecode/decoder_utils.cpp @@ -0,0 +1,174 @@ +#include "decoder_utils.h" + +#include +#include +#include + +std::vector> get_pruned_log_probs( + const std::vector &prob_step, + double cutoff_prob, + size_t cutoff_top_n) { + std::vector> prob_idx; + for (size_t i = 0; i < prob_step.size(); ++i) { + prob_idx.push_back(std::pair(i, prob_step[i])); + } + // pruning of vacobulary + size_t cutoff_len = prob_step.size(); + if (cutoff_prob < 1.0 || cutoff_top_n < cutoff_len) { + std::sort( + prob_idx.begin(), prob_idx.end(), pair_comp_second_rev); + if (cutoff_prob < 1.0) { + double cum_prob = 0.0; + cutoff_len = 0; + for (size_t i = 0; i < prob_idx.size(); ++i) { + cum_prob += prob_idx[i].second; + cutoff_len += 1; + if (cum_prob >= cutoff_prob || cutoff_len >= cutoff_top_n) break; + } + } + prob_idx = std::vector>( + prob_idx.begin(), prob_idx.begin() + cutoff_len); + } + std::vector> log_prob_idx; + for (size_t i = 0; i < cutoff_len; ++i) { + log_prob_idx.push_back(std::pair( + prob_idx[i].first, log(prob_idx[i].second + NUM_FLT_MIN))); + } + return log_prob_idx; +} + + +std::vector> get_beam_search_result( + const std::vector &prefixes, + size_t beam_size) { + // allow for the post processing + std::vector space_prefixes; + if (space_prefixes.empty()) { + for (size_t i = 0; i < beam_size && i < prefixes.size(); ++i) { + space_prefixes.push_back(prefixes[i]); + } + } + + std::sort(space_prefixes.begin(), space_prefixes.end(), prefix_compare); + std::vector> output_vecs; + for (size_t i = 0; i < beam_size && i < space_prefixes.size(); ++i) { + std::vector output; + std::vector timesteps; + space_prefixes[i]->get_path_vec(output, timesteps); + Output outputs; + outputs.tokens = output; + outputs.timesteps = timesteps; + std::pair output_pair(-space_prefixes[i]->approx_ctc, + outputs); + output_vecs.emplace_back(output_pair); + } + + return output_vecs; +} + +size_t get_utf8_str_len(const std::string &str) { + size_t str_len = 0; + for (char c : str) { + str_len += ((c & 0xc0) != 0x80); + } + return str_len; +} + +std::vector split_utf8_str(const std::string &str) { + std::vector result; + std::string out_str; + + for (char c : str) { + if ((c & 0xc0) != 0x80) // new UTF-8 character + { + if (!out_str.empty()) { + result.push_back(out_str); + out_str.clear(); + } + } + + out_str.append(1, c); + } + result.push_back(out_str); + return result; +} + +std::vector split_str(const std::string &s, + const std::string &delim) { + std::vector result; + std::size_t start = 0, delim_len = delim.size(); + while (true) { + std::size_t end = s.find(delim, start); + if (end == std::string::npos) { + if (start < s.size()) { + result.push_back(s.substr(start)); + } + break; + } + if (end > start) { + result.push_back(s.substr(start, end - start)); + } + start = end + delim_len; + } + return result; +} + +bool prefix_compare(const PathTrie *x, const PathTrie *y) { + if (x->score == y->score) { + if (x->character == y->character) { + return false; + } else { + return (x->character < y->character); + } + } else { + return x->score > y->score; + } +} + +void add_word_to_fst(const std::vector &word, + fst::StdVectorFst *dictionary) { + if (dictionary->NumStates() == 0) { + fst::StdVectorFst::StateId start = dictionary->AddState(); + assert(start == 0); + dictionary->SetStart(start); + } + fst::StdVectorFst::StateId src = dictionary->Start(); + fst::StdVectorFst::StateId dst; + for (auto c : word) { + dst = dictionary->AddState(); + dictionary->AddArc(src, fst::StdArc(c, c, 0, dst)); + src = dst; + } + dictionary->SetFinal(dst, fst::StdArc::Weight::One()); +} + +bool add_word_to_dictionary( + const std::string &word, + const std::unordered_map &char_map, + bool add_space, + int SPACE_ID, + fst::StdVectorFst *dictionary) { + auto characters = split_utf8_str(word); + + std::vector int_word; + + for (auto &c : characters) { + if (c == " ") { + int_word.push_back(SPACE_ID); + } else { + auto int_c = char_map.find(c); + if (int_c != char_map.end()) { + int_word.push_back(int_c->second); + } else { + return false; // return without adding + } + } + } + + if (add_space) { + int_word.push_back(SPACE_ID); + } + + add_word_to_fst(int_word, dictionary); + return true; // return with successful adding +} \ No newline at end of file diff --git a/native_client/ctcdecode/decoder_utils.h b/native_client/ctcdecode/decoder_utils.h new file mode 100644 index 0000000000..1bc751078d --- /dev/null +++ b/native_client/ctcdecode/decoder_utils.h @@ -0,0 +1,95 @@ +#ifndef DECODER_UTILS_H_ +#define DECODER_UTILS_H_ + +#include +#include "fst/log.h" +#include "path_trie.h" +#include "output.h" + +const float NUM_FLT_INF = std::numeric_limits::max(); +const float NUM_FLT_MIN = std::numeric_limits::min(); +const float NUM_FLT_LOGE = 0.4342944819; + +// inline function for validation check +inline void check( + bool x, const char *expr, const char *file, int line, const char *err) { + if (!x) { + std::cout << "[" << file << ":" << line << "] "; + LOG(FATAL) << "\"" << expr << "\" check failed. " << err; + } +} + +#define VALID_CHECK(x, info) \ + check(static_cast(x), #x, __FILE__, __LINE__, info) +#define VALID_CHECK_EQ(x, y, info) VALID_CHECK((x) == (y), info) +#define VALID_CHECK_GT(x, y, info) VALID_CHECK((x) > (y), info) +#define VALID_CHECK_LT(x, y, info) VALID_CHECK((x) < (y), info) + + +// Function template for comparing two pairs +template +bool pair_comp_first_rev(const std::pair &a, + const std::pair &b) { + return a.first > b.first; +} + +// Function template for comparing two pairs +template +bool pair_comp_second_rev(const std::pair &a, + const std::pair &b) { + return a.second > b.second; +} + +// Return the sum of two probabilities in log scale +template +T log_sum_exp(const T &x, const T &y) { + static T num_min = -std::numeric_limits::max(); + if (x <= num_min) return y; + if (y <= num_min) return x; + T xmax = std::max(x, y); + return std::log(std::exp(x - xmax) + std::exp(y - xmax)) + xmax; +} + +// Get pruned probability vector for each time step's beam search +std::vector> get_pruned_log_probs( + const std::vector &prob_step, + double cutoff_prob, + size_t cutoff_top_n); + +// Get beam search result from prefixes in trie tree +std::vector> get_beam_search_result( + const std::vector &prefixes, + size_t beam_size); + +// Functor for prefix comparsion +bool prefix_compare(const PathTrie *x, const PathTrie *y); + +/* Get length of utf8 encoding string + * See: http://stackoverflow.com/a/4063229 + */ +size_t get_utf8_str_len(const std::string &str); + +/* Split a string into a list of strings on a given string + * delimiter. NB: delimiters on beginning / end of string are + * trimmed. Eg, "FooBarFoo" split on "Foo" returns ["Bar"]. + */ +std::vector split_str(const std::string &s, + const std::string &delim); + +/* Splits string into vector of strings representing + * UTF-8 characters (not same as chars) + */ +std::vector split_utf8_str(const std::string &str); + +// Add a word in index to the dicionary of fst +void add_word_to_fst(const std::vector &word, + fst::StdVectorFst *dictionary); + +// Add a word in string to dictionary +bool add_word_to_dictionary( + const std::string &word, + const std::unordered_map &char_map, + bool add_space, + int SPACE_ID, + fst::StdVectorFst *dictionary); +#endif // DECODER_UTILS_H diff --git a/native_client/ctcdecode/output.h b/native_client/ctcdecode/output.h new file mode 100644 index 0000000000..a921ee2ca2 --- /dev/null +++ b/native_client/ctcdecode/output.h @@ -0,0 +1,11 @@ +#ifndef OUTPUT_H_ +#define OUTPUT_H_ + +/* Struct for the beam search output, containing the tokens based on the vocabulary indices, and the timesteps + * for each token in the beam search output + */ +struct Output { + std::vector tokens, timesteps; +}; + +#endif // OUTPUT_H_ diff --git a/native_client/ctcdecode/path_trie.cpp b/native_client/ctcdecode/path_trie.cpp new file mode 100644 index 0000000000..3b081290b6 --- /dev/null +++ b/native_client/ctcdecode/path_trie.cpp @@ -0,0 +1,167 @@ +#include "path_trie.h" + +#include +#include +#include +#include +#include + +#include "decoder_utils.h" + +PathTrie::PathTrie() { + log_prob_b_prev = -NUM_FLT_INF; + log_prob_nb_prev = -NUM_FLT_INF; + log_prob_b_cur = -NUM_FLT_INF; + log_prob_nb_cur = -NUM_FLT_INF; + score = -NUM_FLT_INF; + + ROOT_ = -1; + character = ROOT_; + timestep = 0; + exists_ = true; + parent = nullptr; + + dictionary_ = nullptr; + dictionary_state_ = 0; + has_dictionary_ = false; + + matcher_ = nullptr; +} + +PathTrie::~PathTrie() { + for (auto child : children_) { + delete child.second; + } +} + +PathTrie* PathTrie::get_path_trie(int new_char, int new_timestep, bool reset) { + auto child = children_.begin(); + for (child = children_.begin(); child != children_.end(); ++child) { + if (child->first == new_char) { + break; + } + } + if (child != children_.end()) { + if (!child->second->exists_) { + child->second->exists_ = true; + child->second->log_prob_b_prev = -NUM_FLT_INF; + child->second->log_prob_nb_prev = -NUM_FLT_INF; + child->second->log_prob_b_cur = -NUM_FLT_INF; + child->second->log_prob_nb_cur = -NUM_FLT_INF; + } + return (child->second); + } else { + if (has_dictionary_) { + matcher_->SetState(dictionary_state_); + bool found = matcher_->Find(new_char + 1); + if (!found) { + // Adding this character causes word outside dictionary + auto FSTZERO = fst::TropicalWeight::Zero(); + auto final_weight = dictionary_->Final(dictionary_state_); + bool is_final = (final_weight != FSTZERO); + if (is_final && reset) { + dictionary_state_ = dictionary_->Start(); + } + return nullptr; + } else { + PathTrie* new_path = new PathTrie; + new_path->character = new_char; + new_path->timestep = new_timestep; + new_path->parent = this; + new_path->dictionary_ = dictionary_; + new_path->has_dictionary_ = true; + new_path->matcher_ = matcher_; + + // set spell checker state + // check to see if next state is final + auto FSTZERO = fst::TropicalWeight::Zero(); + auto final_weight = dictionary_->Final(matcher_->Value().nextstate); + bool is_final = (final_weight != FSTZERO); + if (is_final && reset) { + // restart spell checker at the start state + new_path->dictionary_state_ = dictionary_->Start(); + } else { + // go to next state + new_path->dictionary_state_ = matcher_->Value().nextstate; + } + + children_.push_back(std::make_pair(new_char, new_path)); + return new_path; + } + } else { + PathTrie* new_path = new PathTrie; + new_path->character = new_char; + new_path->timestep = new_timestep; + new_path->parent = this; + children_.push_back(std::make_pair(new_char, new_path)); + return new_path; + } + } +} + +PathTrie* PathTrie::get_path_vec(std::vector& output, std::vector& timesteps) { + return get_path_vec(output, timesteps, ROOT_); +} + +PathTrie* PathTrie::get_path_vec(std::vector& output, + std::vector& timesteps, + int stop, + size_t max_steps) { + if (character == stop || character == ROOT_ || output.size() == max_steps) { + std::reverse(output.begin(), output.end()); + std::reverse(timesteps.begin(), timesteps.end()); + return this; + } else { + output.push_back(character); + timesteps.push_back(timestep); + return parent->get_path_vec(output, timesteps, stop, max_steps); + } +} + +void PathTrie::iterate_to_vec(std::vector& output) { + if (exists_) { + log_prob_b_prev = log_prob_b_cur; + log_prob_nb_prev = log_prob_nb_cur; + + log_prob_b_cur = -NUM_FLT_INF; + log_prob_nb_cur = -NUM_FLT_INF; + + score = log_sum_exp(log_prob_b_prev, log_prob_nb_prev); + output.push_back(this); + } + for (auto child : children_) { + child.second->iterate_to_vec(output); + } +} + +void PathTrie::remove() { + exists_ = false; + + if (children_.size() == 0) { + auto child = parent->children_.begin(); + for (child = parent->children_.begin(); child != parent->children_.end(); + ++child) { + if (child->first == character) { + parent->children_.erase(child); + break; + } + } + + if (parent->children_.size() == 0 && !parent->exists_) { + parent->remove(); + } + + delete this; + } +} + +void PathTrie::set_dictionary(fst::StdVectorFst* dictionary) { + dictionary_ = dictionary; + dictionary_state_ = dictionary->Start(); + has_dictionary_ = true; +} + +using FSTMATCH = fst::SortedMatcher; +void PathTrie::set_matcher(std::shared_ptr matcher) { + matcher_ = matcher; +} diff --git a/native_client/ctcdecode/path_trie.h b/native_client/ctcdecode/path_trie.h new file mode 100644 index 0000000000..5641593364 --- /dev/null +++ b/native_client/ctcdecode/path_trie.h @@ -0,0 +1,69 @@ +#ifndef PATH_TRIE_H +#define PATH_TRIE_H + +#include +#include +#include +#include +#include + +#include "fst/fstlib.h" + +/* Trie tree for prefix storing and manipulating, with a dictionary in + * finite-state transducer for spelling correction. + */ +class PathTrie { +public: + PathTrie(); + ~PathTrie(); + + // get new prefix after appending new char + PathTrie* get_path_trie(int new_char, int new_timestep, bool reset = true); + + // get the prefix in index from root to current node + PathTrie* get_path_vec(std::vector& output, std::vector& timesteps); + + // get the prefix in index from some stop node to current nodel + PathTrie* get_path_vec(std::vector& output, + std::vector& timesteps, + int stop, + size_t max_steps = std::numeric_limits::max()); + + // update log probs + void iterate_to_vec(std::vector& output); + + // set dictionary for FST + void set_dictionary(fst::StdVectorFst* dictionary); + + void set_matcher(std::shared_ptr>); + + bool is_empty() { return ROOT_ == character; } + + // remove current path from root + void remove(); + + float log_prob_b_prev; + float log_prob_nb_prev; + float log_prob_b_cur; + float log_prob_nb_cur; + float score; + float approx_ctc; + int character; + int timestep; + PathTrie* parent; + +private: + int ROOT_; + bool exists_; + bool has_dictionary_; + + std::vector> children_; + + // pointer to dictionary of FST + fst::StdVectorFst* dictionary_; + fst::StdVectorFst::StateId dictionary_state_; + // true if finding ars in FST + std::shared_ptr> matcher_; +}; + +#endif // PATH_TRIE_H diff --git a/native_client/ctcdecode/scorer.cpp b/native_client/ctcdecode/scorer.cpp new file mode 100644 index 0000000000..05ed356706 --- /dev/null +++ b/native_client/ctcdecode/scorer.cpp @@ -0,0 +1,243 @@ +#include "scorer.h" + +#include +#include +#include + +#include "lm/config.hh" +#include "lm/model.hh" +#include "lm/state.hh" +#include "util/string_piece.hh" + +#include "decoder_utils.h" + +using namespace lm::ngram; + +static const int MAGIC = 'TRIE'; +static const int FILE_VERSION = 3; + +Scorer::Scorer(double alpha, + double beta, + const std::string& lm_path, + const std::string& trie_path, + const Alphabet& alphabet) + : dictionary() + , language_model_() + , is_character_based_(true) + , max_order_(0) + , alphabet_(alphabet) +{ + reset_params(alpha, beta); + + char_map_.clear(); + + SPACE_ID_ = alphabet_.GetSpaceLabel(); + + for (int i = 0; i < alphabet_.GetSize(); i++) { + // The initial state of FST is state 0, hence the index of chars in + // the FST should start from 1 to avoid the conflict with the initial + // state, otherwise wrong decoding results would be given. + char_map_[alphabet_.StringFromLabel(i)] = i + 1; + } + + setup(lm_path, trie_path); +} + +Scorer::~Scorer() { +} + +void Scorer::setup(const std::string& lm_path, const std::string& trie_path) { + // load language model + const char* filename = lm_path.c_str(); + VALID_CHECK_EQ(access(filename, R_OK), 0, "Invalid language model path"); + + bool has_trie = trie_path.size() && access(trie_path.c_str(), R_OK) == 0; + + lm::ngram::Config config; + + if (!has_trie) { // no trie was specified, build it now + RetrieveStrEnumerateVocab enumerate; + config.enumerate_vocab = &enumerate; + language_model_.reset(lm::ngram::LoadVirtual(filename, config)); + auto vocab = enumerate.vocabulary; + for (size_t i = 0; i < vocab.size(); ++i) { + if (is_character_based_ && vocab[i] != UNK_TOKEN && + vocab[i] != START_TOKEN && vocab[i] != END_TOKEN && + get_utf8_str_len(enumerate.vocabulary[i]) > 1) { + is_character_based_ = false; + } + } + // fill the dictionary for FST + if (!is_character_based()) { + fill_dictionary(vocab, true); + } + } else { + language_model_.reset(lm::ngram::LoadVirtual(filename, config)); + + // Read metadata and trie from file + std::ifstream fin(trie_path, std::ios::binary); + + int magic; + fin.read(reinterpret_cast(&magic), sizeof(magic)); + if (magic != MAGIC) { + std::cerr << "Error: Can't parse trie file, invalid header. Try updating " + "your trie file." << std::endl; + throw 1; + } + + int version; + fin.read(reinterpret_cast(&version), sizeof(version)); + if (version != FILE_VERSION) { + std::cerr << "Error: Trie file version mismatch (" << version + << " instead of expected " << FILE_VERSION + << "). Update your trie file." + << std::endl; + throw 1; + } + + fin.read(reinterpret_cast(&is_character_based_), sizeof(is_character_based_)); + + fst::FstReadOptions opt; + dictionary.reset(fst::StdVectorFst::Read(fin, opt)); + } + + max_order_ = language_model_->Order(); +} + +void Scorer::save_dictionary(const std::string& path) { + std::ofstream fout(path, std::ios::binary); + fout.write(reinterpret_cast(&MAGIC), sizeof(MAGIC)); + fout.write(reinterpret_cast(&FILE_VERSION), sizeof(FILE_VERSION)); + fout.write(reinterpret_cast(&is_character_based_), sizeof(is_character_based_)); + fst::FstWriteOptions opt; + dictionary->Write(fout, opt); +} + +double Scorer::get_log_cond_prob(const std::vector& words) { + double cond_prob; + lm::ngram::State state, tmp_state, out_state; + // avoid to inserting in begin + language_model_->NullContextWrite(&state); + for (size_t i = 0; i < words.size(); ++i) { + lm::WordIndex word_index = language_model_->BaseVocabulary().Index(words[i]); + // encounter OOV + if (word_index == 0) { + return OOV_SCORE; + } + cond_prob = language_model_->BaseScore(&state, word_index, &out_state); + tmp_state = state; + state = out_state; + out_state = tmp_state; + } + // return loge prob + return cond_prob/NUM_FLT_LOGE; +} + +double Scorer::get_sent_log_prob(const std::vector& words) { + std::vector sentence; + if (words.size() == 0) { + for (size_t i = 0; i < max_order_; ++i) { + sentence.push_back(START_TOKEN); + } + } else { + for (size_t i = 0; i < max_order_ - 1; ++i) { + sentence.push_back(START_TOKEN); + } + sentence.insert(sentence.end(), words.begin(), words.end()); + } + sentence.push_back(END_TOKEN); + return get_log_prob(sentence); +} + +double Scorer::get_log_prob(const std::vector& words) { + assert(words.size() > max_order_); + double score = 0.0; + for (size_t i = 0; i < words.size() - max_order_ + 1; ++i) { + std::vector ngram(words.begin() + i, + words.begin() + i + max_order_); + score += get_log_cond_prob(ngram); + } + return score; +} + +void Scorer::reset_params(float alpha, float beta) { + this->alpha = alpha; + this->beta = beta; +} + +std::vector Scorer::split_labels(const std::vector& labels) { + if (labels.empty()) return {}; + + std::string s = alphabet_.LabelsToString(labels); + std::vector words; + if (is_character_based_) { + words = split_utf8_str(s); + } else { + words = split_str(s, " "); + } + return words; +} + +std::vector Scorer::make_ngram(PathTrie* prefix) { + std::vector ngram; + PathTrie* current_node = prefix; + PathTrie* new_node = nullptr; + + for (int order = 0; order < max_order_; order++) { + std::vector prefix_vec; + std::vector prefix_steps; + + if (is_character_based_) { + new_node = current_node->get_path_vec(prefix_vec, prefix_steps, SPACE_ID_, 1); + current_node = new_node; + } else { + new_node = current_node->get_path_vec(prefix_vec, prefix_steps, SPACE_ID_); + current_node = new_node->parent; // Skipping spaces + } + + // reconstruct word + std::string word = alphabet_.LabelsToString(prefix_vec); + ngram.push_back(word); + + if (new_node->character == -1) { + // No more spaces, but still need order + for (int i = 0; i < max_order_ - order - 1; i++) { + ngram.push_back(START_TOKEN); + } + break; + } + } + std::reverse(ngram.begin(), ngram.end()); + return ngram; +} + +void Scorer::fill_dictionary(const std::vector& vocabulary, bool add_space) { + fst::StdVectorFst dictionary; + // For each unigram convert to ints and put in trie + for (const auto& word : vocabulary) { + add_word_to_dictionary(word, char_map_, add_space, SPACE_ID_ + 1, &dictionary); + } + + /* Simplify FST + + * This gets rid of "epsilon" transitions in the FST. + * These are transitions that don't require a string input to be taken. + * Getting rid of them is necessary to make the FST determinisitc, but + * can greatly increase the size of the FST + */ + fst::RmEpsilon(&dictionary); + fst::StdVectorFst* new_dict = new fst::StdVectorFst; + + /* This makes the FST deterministic, meaning for any string input there's + * only one possible state the FST could be in. It is assumed our + * dictionary is deterministic when using it. + * (lest we'd have to check for multiple transitions at each state) + */ + fst::Determinize(dictionary, new_dict); + + /* Finds the simplest equivalent fst. This is unnecessary but decreases + * memory usage of the dictionary + */ + fst::Minimize(new_dict); + this->dictionary.reset(new_dict); +} diff --git a/native_client/ctcdecode/scorer.h b/native_client/ctcdecode/scorer.h new file mode 100644 index 0000000000..4841d7b107 --- /dev/null +++ b/native_client/ctcdecode/scorer.h @@ -0,0 +1,104 @@ +#ifndef SCORER_H_ +#define SCORER_H_ + +#include +#include +#include +#include + +#include "lm/enumerate_vocab.hh" +#include "lm/virtual_interface.hh" +#include "lm/word_index.hh" +#include "util/string_piece.hh" + +#include "path_trie.h" +#include "alphabet.h" + +const double OOV_SCORE = -1000.0; +const std::string START_TOKEN = ""; +const std::string UNK_TOKEN = ""; +const std::string END_TOKEN = ""; + +// Implement a callback to retrieve the dictionary of language model. +class RetrieveStrEnumerateVocab : public lm::EnumerateVocab { +public: + RetrieveStrEnumerateVocab() {} + + void Add(lm::WordIndex index, const StringPiece &str) { + vocabulary.push_back(std::string(str.data(), str.length())); + } + + std::vector vocabulary; +}; + +/* External scorer to query score for n-gram or sentence, including language + * model scoring and word insertion. + * + * Example: + * Scorer scorer(alpha, beta, "path_of_language_model"); + * scorer.get_log_cond_prob({ "WORD1", "WORD2", "WORD3" }); + * scorer.get_sent_log_prob({ "WORD1", "WORD2", "WORD3" }); + */ +class Scorer { +public: + Scorer(double alpha, + double beta, + const std::string &lm_path, + const std::string &trie_path, + const Alphabet &alphabet); + ~Scorer(); + + double get_log_cond_prob(const std::vector &words); + + double get_sent_log_prob(const std::vector &words); + + // return the max order + size_t get_max_order() const { return max_order_; } + + // retrun true if the language model is character based + bool is_character_based() const { return is_character_based_; } + + // reset params alpha & beta + void reset_params(float alpha, float beta); + + // make ngram for a given prefix + std::vector make_ngram(PathTrie *prefix); + + // trransform the labels in index to the vector of words (word based lm) or + // the vector of characters (character based lm) + std::vector split_labels(const std::vector &labels); + + // save dictionary in file + void save_dictionary(const std::string &path); + + // language model weight + double alpha; + // word insertion weight + double beta; + + // pointer to the dictionary of FST + std::unique_ptr dictionary; + +protected: + // necessary setup: load language model, fill FST's dictionary + void setup(const std::string &lm_path, const std::string &trie_path); + + // load language model from given path + void load_lm(const std::string &lm_path); + + // fill dictionary for FST + void fill_dictionary(const std::vector &vocabulary, bool add_space); + + double get_log_prob(const std::vector &words); + +private: + std::unique_ptr language_model_; + bool is_character_based_; + size_t max_order_; + + int SPACE_ID_; + Alphabet alphabet_; + std::unordered_map char_map_; +}; + +#endif // SCORER_H_ diff --git a/native_client/ctcdecode/third_party/ThreadPool/COPYING b/native_client/ctcdecode/third_party/ThreadPool/COPYING new file mode 100644 index 0000000000..7d69178f4e --- /dev/null +++ b/native_client/ctcdecode/third_party/ThreadPool/COPYING @@ -0,0 +1,20 @@ +Copyright (c) 2012 Jakob Progsch, Václav Zeman + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any damages +arising from the use of this software. + +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it +freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + + 3. This notice may not be removed or altered from any source + distribution. diff --git a/native_client/ctcdecode/third_party/ThreadPool/README.md b/native_client/ctcdecode/third_party/ThreadPool/README.md new file mode 100644 index 0000000000..be3d25ac4c --- /dev/null +++ b/native_client/ctcdecode/third_party/ThreadPool/README.md @@ -0,0 +1,17 @@ +ThreadPool +========== + +A simple C++11 Thread Pool implementation. + +Basic usage: +```c++ +// create thread pool with 4 worker threads +ThreadPool pool(4); + +// enqueue and store future +auto result = pool.enqueue([](int answer) { return answer; }, 42); + +// get result from future +std::cout << result.get() << std::endl; + +``` diff --git a/native_client/ctcdecode/third_party/ThreadPool/ThreadPool.h b/native_client/ctcdecode/third_party/ThreadPool/ThreadPool.h new file mode 100644 index 0000000000..4183203078 --- /dev/null +++ b/native_client/ctcdecode/third_party/ThreadPool/ThreadPool.h @@ -0,0 +1,98 @@ +#ifndef THREAD_POOL_H +#define THREAD_POOL_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +class ThreadPool { +public: + ThreadPool(size_t); + template + auto enqueue(F&& f, Args&&... args) + -> std::future::type>; + ~ThreadPool(); +private: + // need to keep track of threads so we can join them + std::vector< std::thread > workers; + // the task queue + std::queue< std::function > tasks; + + // synchronization + std::mutex queue_mutex; + std::condition_variable condition; + bool stop; +}; + +// the constructor just launches some amount of workers +inline ThreadPool::ThreadPool(size_t threads) + : stop(false) +{ + for(size_t i = 0;i task; + + { + std::unique_lock lock(this->queue_mutex); + this->condition.wait(lock, + [this]{ return this->stop || !this->tasks.empty(); }); + if(this->stop && this->tasks.empty()) + return; + task = std::move(this->tasks.front()); + this->tasks.pop(); + } + + task(); + } + } + ); +} + +// add new work item to the pool +template +auto ThreadPool::enqueue(F&& f, Args&&... args) + -> std::future::type> +{ + using return_type = typename std::result_of::type; + + auto task = std::make_shared< std::packaged_task >( + std::bind(std::forward(f), std::forward(args)...) + ); + + std::future res = task->get_future(); + { + std::unique_lock lock(queue_mutex); + + // don't allow enqueueing after stopping the pool + if(stop) + throw std::runtime_error("enqueue on stopped ThreadPool"); + + tasks.emplace([task](){ (*task)(); }); + } + condition.notify_one(); + return res; +} + +// the destructor joins all threads +inline ThreadPool::~ThreadPool() +{ + { + std::unique_lock lock(queue_mutex); + stop = true; + } + condition.notify_all(); + for(std::thread &worker: workers) + worker.join(); +} + +#endif diff --git a/native_client/ctcdecode/third_party/ThreadPool/example.cpp b/native_client/ctcdecode/third_party/ThreadPool/example.cpp new file mode 100644 index 0000000000..837277b99d --- /dev/null +++ b/native_client/ctcdecode/third_party/ThreadPool/example.cpp @@ -0,0 +1,29 @@ +#include +#include +#include + +#include "ThreadPool.h" + +int main() +{ + + ThreadPool pool(4); + std::vector< std::future > results; + + for(int i = 0; i < 8; ++i) { + results.emplace_back( + pool.enqueue([i] { + std::cout << "hello " << i << std::endl; + std::this_thread::sleep_for(std::chrono::seconds(1)); + std::cout << "world " << i << std::endl; + return i*i; + }) + ); + } + + for(auto && result: results) + std::cout << result.get() << ' '; + std::cout << std::endl; + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/AUTHORS b/native_client/ctcdecode/third_party/openfst-1.6.7/AUTHORS new file mode 100644 index 0000000000..6840e8bb3a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/AUTHORS @@ -0,0 +1,28 @@ +Principal Contacts: + +Cyril Allauzen +Michael Riley + +Contributors: + +These contributions range from fundamental algorithmic contributions (e.g., +Mehryar Mohri) to implementation of core components and extensions. + +Tom Bagby +Dan Bikel +Kyle Gorman +Martin Jansche +Boulos Harb +Mehryar Mohri +Dan Povey +Kasturi Raghavan +Jacob Ratkiewicz +Jesse Rosenstock +Johan Schalkwyk +Masha Shugrina +Wojtek Skut +Jeffrey Sorensen +Richard Sproat +Ananda Theertha Suresh +Terry Tai +Ke Wu diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/COPYING b/native_client/ctcdecode/third_party/openfst-1.6.7/COPYING new file mode 100644 index 0000000000..3633a95474 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/COPYING @@ -0,0 +1,13 @@ +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use these files except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + +Copyright 2005-2018 Google, Inc. diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/INSTALL b/native_client/ctcdecode/third_party/openfst-1.6.7/INSTALL new file mode 100644 index 0000000000..d3c5b40a94 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/INSTALL @@ -0,0 +1,237 @@ +Installation Instructions +************************* + +Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002, 2004, 2005, +2006, 2007 Free Software Foundation, Inc. + +This file is free documentation; the Free Software Foundation gives +unlimited permission to copy, distribute and modify it. + +Basic Installation +================== + +Briefly, the shell commands `./configure; make; make install' should +configure, build, and install this package. The following +more-detailed instructions are generic; see the `README' file for +instructions specific to this package. + + The `configure' shell script attempts to guess correct values for +various system-dependent variables used during compilation. It uses +those values to create a `Makefile' in each directory of the package. +It may also create one or more `.h' files containing system-dependent +definitions. Finally, it creates a shell script `config.status' that +you can run in the future to recreate the current configuration, and a +file `config.log' containing compiler output (useful mainly for +debugging `configure'). + + It can also use an optional file (typically called `config.cache' +and enabled with `--cache-file=config.cache' or simply `-C') that saves +the results of its tests to speed up reconfiguring. Caching is +disabled by default to prevent problems with accidental use of stale +cache files. + + If you need to do unusual things to compile the package, please try +to figure out how `configure' could check whether to do them, and mail +diffs or instructions to the address given in the `README' so they can +be considered for the next release. If you are using the cache, and at +some point `config.cache' contains results you don't want to keep, you +may remove or edit it. + + The file `configure.ac' (or `configure.in') is used to create +`configure' by a program called `autoconf'. You need `configure.ac' if +you want to change it or regenerate `configure' using a newer version +of `autoconf'. + +The simplest way to compile this package is: + + 1. `cd' to the directory containing the package's source code and type + `./configure' to configure the package for your system. + + Running `configure' might take a while. While running, it prints + some messages telling which features it is checking for. + + 2. Type `make' to compile the package. + + 3. Optionally, type `make check' to run any self-tests that come with + the package. + + 4. Type `make install' to install the programs and any data files and + documentation. + + 5. You can remove the program binaries and object files from the + source code directory by typing `make clean'. To also remove the + files that `configure' created (so you can compile the package for + a different kind of computer), type `make distclean'. There is + also a `make maintainer-clean' target, but that is intended mainly + for the package's developers. If you use it, you may have to get + all sorts of other programs in order to regenerate files that came + with the distribution. + + 6. Often, you can also type `make uninstall' to remove the installed + files again. + +Compilers and Options +===================== + +Some systems require unusual options for compilation or linking that the +`configure' script does not know about. Run `./configure --help' for +details on some of the pertinent environment variables. + + You can give `configure' initial values for configuration parameters +by setting variables in the command line or in the environment. Here +is an example: + + ./configure CC=c99 CFLAGS=-g LIBS=-lposix + + *Note Defining Variables::, for more details. + +Compiling For Multiple Architectures +==================================== + +You can compile the package for more than one kind of computer at the +same time, by placing the object files for each architecture in their +own directory. To do this, you can use GNU `make'. `cd' to the +directory where you want the object files and executables to go and run +the `configure' script. `configure' automatically checks for the +source code in the directory that `configure' is in and in `..'. + + With a non-GNU `make', it is safer to compile the package for one +architecture at a time in the source code directory. After you have +installed the package for one architecture, use `make distclean' before +reconfiguring for another architecture. + +Installation Names +================== + +By default, `make install' installs the package's commands under +`/usr/local/bin', include files under `/usr/local/include', etc. You +can specify an installation prefix other than `/usr/local' by giving +`configure' the option `--prefix=PREFIX'. + + You can specify separate installation prefixes for +architecture-specific files and architecture-independent files. If you +pass the option `--exec-prefix=PREFIX' to `configure', the package uses +PREFIX as the prefix for installing programs and libraries. +Documentation and other data files still use the regular prefix. + + In addition, if you use an unusual directory layout you can give +options like `--bindir=DIR' to specify different values for particular +kinds of files. Run `configure --help' for a list of the directories +you can set and what kinds of files go in them. + + If the package supports it, you can cause programs to be installed +with an extra prefix or suffix on their names by giving `configure' the +option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'. + +Optional Features +================= + +Some packages pay attention to `--enable-FEATURE' options to +`configure', where FEATURE indicates an optional part of the package. +They may also pay attention to `--with-PACKAGE' options, where PACKAGE +is something like `gnu-as' or `x' (for the X Window System). The +`README' should mention any `--enable-' and `--with-' options that the +package recognizes. + + For packages that use the X Window System, `configure' can usually +find the X include and library files automatically, but if it doesn't, +you can use the `configure' options `--x-includes=DIR' and +`--x-libraries=DIR' to specify their locations. + +Specifying the System Type +========================== + +There may be some features `configure' cannot figure out automatically, +but needs to determine by the type of machine the package will run on. +Usually, assuming the package is built to be run on the _same_ +architectures, `configure' can figure that out, but if it prints a +message saying it cannot guess the machine type, give it the +`--build=TYPE' option. TYPE can either be a short name for the system +type, such as `sun4', or a canonical name which has the form: + + CPU-COMPANY-SYSTEM + +where SYSTEM can have one of these forms: + + OS KERNEL-OS + + See the file `config.sub' for the possible values of each field. If +`config.sub' isn't included in this package, then this package doesn't +need to know the machine type. + + If you are _building_ compiler tools for cross-compiling, you should +use the option `--target=TYPE' to select the type of system they will +produce code for. + + If you want to _use_ a cross compiler, that generates code for a +platform different from the build platform, you should specify the +"host" platform (i.e., that on which the generated programs will +eventually be run) with `--host=TYPE'. + +Sharing Defaults +================ + +If you want to set default values for `configure' scripts to share, you +can create a site shell script called `config.site' that gives default +values for variables like `CC', `cache_file', and `prefix'. +`configure' looks for `PREFIX/share/config.site' if it exists, then +`PREFIX/etc/config.site' if it exists. Or, you can set the +`CONFIG_SITE' environment variable to the location of the site script. +A warning: not all `configure' scripts look for a site script. + +Defining Variables +================== + +Variables not defined in a site shell script can be set in the +environment passed to `configure'. However, some packages may run +configure again during the build, and the customized values of these +variables may be lost. In order to avoid this problem, you should set +them in the `configure' command line, using `VAR=value'. For example: + + ./configure CC=/usr/local2/bin/gcc + +causes the specified `gcc' to be used as the C compiler (unless it is +overridden in the site shell script). + +Unfortunately, this technique does not work for `CONFIG_SHELL' due to +an Autoconf bug. Until the bug is fixed you can use this workaround: + + CONFIG_SHELL=/bin/bash /bin/bash ./configure CONFIG_SHELL=/bin/bash + +`configure' Invocation +====================== + +`configure' recognizes the following options to control how it operates. + +`--help' +`-h' + Print a summary of the options to `configure', and exit. + +`--version' +`-V' + Print the version of Autoconf used to generate the `configure' + script, and exit. + +`--cache-file=FILE' + Enable the cache: use and save the results of the tests in FILE, + traditionally `config.cache'. FILE defaults to `/dev/null' to + disable caching. + +`--config-cache' +`-C' + Alias for `--cache-file=config.cache'. + +`--quiet' +`--silent' +`-q' + Do not print messages saying which checks are being made. To + suppress all normal output, redirect it to `/dev/null' (any error + messages will still be shown). + +`--srcdir=DIR' + Look for the package's source code in directory DIR. Usually + `configure' can determine that directory automatically. + +`configure' also accepts some other, not widely useful, options. Run +`configure --help' for more details. + diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/Makefile.am b/native_client/ctcdecode/third_party/openfst-1.6.7/Makefile.am new file mode 100644 index 0000000000..0182df2975 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/Makefile.am @@ -0,0 +1,2 @@ +SUBDIRS = src +ACLOCAL_AMFLAGS = -I m4 diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/Makefile.in b/native_client/ctcdecode/third_party/openfst-1.6.7/Makefile.in new file mode 100644 index 0000000000..3dd0a82361 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/Makefile.in @@ -0,0 +1,828 @@ +# Makefile.in generated by automake 1.14.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2013 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ +VPATH = @srcdir@ +am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +subdir = . +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ + $(top_srcdir)/configure $(am__configure_deps) \ + $(srcdir)/config.h.in \ + $(top_srcdir)/src/include/fst/config.h.in AUTHORS COPYING \ + INSTALL NEWS README ar-lib compile config.guess config.sub \ + install-sh missing ltmain.sh +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \ + $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ + $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ + $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \ + configure.lineno config.status.lineno +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = config.h $(top_builddir)/src/include/fst/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +SOURCES = +DIST_SOURCES = +RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \ + ctags-recursive dvi-recursive html-recursive info-recursive \ + install-data-recursive install-dvi-recursive \ + install-exec-recursive install-html-recursive \ + install-info-recursive install-pdf-recursive \ + install-ps-recursive install-recursive installcheck-recursive \ + installdirs-recursive pdf-recursive ps-recursive \ + tags-recursive uninstall-recursive +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \ + distclean-recursive maintainer-clean-recursive +am__recursive_targets = \ + $(RECURSIVE_TARGETS) \ + $(RECURSIVE_CLEAN_TARGETS) \ + $(am__extra_recursive_targets) +AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \ + cscope distdir dist dist-all distcheck +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) \ + $(LISP)config.h.in +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +CSCOPE = cscope +DIST_SUBDIRS = $(SUBDIRS) +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +distdir = $(PACKAGE)-$(VERSION) +top_distdir = $(distdir) +am__remove_distdir = \ + if test -d "$(distdir)"; then \ + find "$(distdir)" -type d ! -perm -200 -exec chmod u+w {} ';' \ + && rm -rf "$(distdir)" \ + || { sleep 5 && rm -rf "$(distdir)"; }; \ + else :; fi +am__post_remove_distdir = $(am__remove_distdir) +am__relativize = \ + dir0=`pwd`; \ + sed_first='s,^\([^/]*\)/.*$$,\1,'; \ + sed_rest='s,^[^/]*/*,,'; \ + sed_last='s,^.*/\([^/]*\)$$,\1,'; \ + sed_butlast='s,/*[^/]*$$,,'; \ + while test -n "$$dir1"; do \ + first=`echo "$$dir1" | sed -e "$$sed_first"`; \ + if test "$$first" != "."; then \ + if test "$$first" = ".."; then \ + dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \ + dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \ + else \ + first2=`echo "$$dir2" | sed -e "$$sed_first"`; \ + if test "$$first2" = "$$first"; then \ + dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \ + else \ + dir2="../$$dir2"; \ + fi; \ + dir0="$$dir0"/"$$first"; \ + fi; \ + fi; \ + dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \ + done; \ + reldir="$$dir2" +DIST_ARCHIVES = $(distdir).tar.gz +GZIP_ENV = --best +DIST_TARGETS = dist-gzip +distuninstallcheck_listfiles = find . -type f -print +am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \ + | sed 's|^\./|$(prefix)/|' | grep -v '$(infodir)/dir$$' +distcleancheck_listfiles = find . -type f -print +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DL_LIBS = @DL_LIBS@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PYTHON = @PYTHON@ +PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@ +PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ +PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@ +PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@ +PYTHON_LDFLAGS = @PYTHON_LDFLAGS@ +PYTHON_PLATFORM = @PYTHON_PLATFORM@ +PYTHON_PREFIX = @PYTHON_PREFIX@ +PYTHON_SITE_PKG = @PYTHON_SITE_PKG@ +PYTHON_VERSION = @PYTHON_VERSION@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +libfstdir = @libfstdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgpyexecdir = @pkgpyexecdir@ +pkgpythondir = @pkgpythondir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +pyexecdir = @pyexecdir@ +pythondir = @pythondir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +SUBDIRS = src +ACLOCAL_AMFLAGS = -I m4 +all: config.h + $(MAKE) $(AM_MAKEFLAGS) all-recursive + +.SUFFIXES: +am--refresh: Makefile + @: +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + echo ' cd $(srcdir) && $(AUTOMAKE) --foreign'; \ + $(am__cd) $(srcdir) && $(AUTOMAKE) --foreign \ + && exit 0; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + echo ' $(SHELL) ./config.status'; \ + $(SHELL) ./config.status;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + $(SHELL) ./config.status --recheck + +$(top_srcdir)/configure: $(am__configure_deps) + $(am__cd) $(srcdir) && $(AUTOCONF) +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + $(am__cd) $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS) +$(am__aclocal_m4_deps): + +config.h: stamp-h1 + @test -f $@ || rm -f stamp-h1 + @test -f $@ || $(MAKE) $(AM_MAKEFLAGS) stamp-h1 + +stamp-h1: $(srcdir)/config.h.in $(top_builddir)/config.status + @rm -f stamp-h1 + cd $(top_builddir) && $(SHELL) ./config.status config.h +$(srcdir)/config.h.in: $(am__configure_deps) + ($(am__cd) $(top_srcdir) && $(AUTOHEADER)) + rm -f stamp-h1 + touch $@ + +src/include/fst/config.h: src/include/fst/stamp-h2 + @test -f $@ || rm -f src/include/fst/stamp-h2 + @test -f $@ || $(MAKE) $(AM_MAKEFLAGS) src/include/fst/stamp-h2 + +src/include/fst/stamp-h2: $(top_srcdir)/src/include/fst/config.h.in $(top_builddir)/config.status + @rm -f src/include/fst/stamp-h2 + cd $(top_builddir) && $(SHELL) ./config.status src/include/fst/config.h + +distclean-hdr: + -rm -f config.h stamp-h1 src/include/fst/config.h src/include/fst/stamp-h2 + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +distclean-libtool: + -rm -f libtool config.lt + +# This directory's subdirectories are mostly independent; you can cd +# into them and run 'make' without going through this Makefile. +# To change the values of 'make' variables: instead of editing Makefiles, +# (1) if the variable is set in 'config.status', edit 'config.status' +# (which will cause the Makefiles to be regenerated when you run 'make'); +# (2) otherwise, pass the desired values on the 'make' command line. +$(am__recursive_targets): + @fail=; \ + if $(am__make_keepgoing); then \ + failcom='fail=yes'; \ + else \ + failcom='exit 1'; \ + fi; \ + dot_seen=no; \ + target=`echo $@ | sed s/-recursive//`; \ + case "$@" in \ + distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \ + *) list='$(SUBDIRS)' ;; \ + esac; \ + for subdir in $$list; do \ + echo "Making $$target in $$subdir"; \ + if test "$$subdir" = "."; then \ + dot_seen=yes; \ + local_target="$$target-am"; \ + else \ + local_target="$$target"; \ + fi; \ + ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ + || eval $$failcom; \ + done; \ + if test "$$dot_seen" = "no"; then \ + $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \ + fi; test -z "$$fail" + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-recursive +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \ + include_option=--etags-include; \ + empty_fix=.; \ + else \ + include_option=--include; \ + empty_fix=; \ + fi; \ + list='$(SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + test ! -f $$subdir/TAGS || \ + set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \ + fi; \ + done; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-recursive + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscope: cscope.files + test ! -s cscope.files \ + || $(CSCOPE) -b -q $(AM_CSCOPEFLAGS) $(CSCOPEFLAGS) -i cscope.files $(CSCOPE_ARGS) +clean-cscope: + -rm -f cscope.files +cscope.files: clean-cscope cscopelist +cscopelist: cscopelist-recursive + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + -rm -f cscope.out cscope.in.out cscope.po.out cscope.files + +distdir: $(DISTFILES) + $(am__remove_distdir) + test -d "$(distdir)" || mkdir "$(distdir)" + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done + @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + $(am__make_dryrun) \ + || test -d "$(distdir)/$$subdir" \ + || $(MKDIR_P) "$(distdir)/$$subdir" \ + || exit 1; \ + dir1=$$subdir; dir2="$(distdir)/$$subdir"; \ + $(am__relativize); \ + new_distdir=$$reldir; \ + dir1=$$subdir; dir2="$(top_distdir)"; \ + $(am__relativize); \ + new_top_distdir=$$reldir; \ + echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \ + echo " am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \ + ($(am__cd) $$subdir && \ + $(MAKE) $(AM_MAKEFLAGS) \ + top_distdir="$$new_top_distdir" \ + distdir="$$new_distdir" \ + am__remove_distdir=: \ + am__skip_length_check=: \ + am__skip_mode_fix=: \ + distdir) \ + || exit 1; \ + fi; \ + done + -test -n "$(am__skip_mode_fix)" \ + || find "$(distdir)" -type d ! -perm -755 \ + -exec chmod u+rwx,go+rx {} \; -o \ + ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \ + ! -type d ! -perm -400 -exec chmod a+r {} \; -o \ + ! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \ + || chmod -R a+r "$(distdir)" +dist-gzip: distdir + tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz + $(am__post_remove_distdir) + +dist-bzip2: distdir + tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2 + $(am__post_remove_distdir) + +dist-lzip: distdir + tardir=$(distdir) && $(am__tar) | lzip -c $${LZIP_OPT--9} >$(distdir).tar.lz + $(am__post_remove_distdir) + +dist-xz: distdir + tardir=$(distdir) && $(am__tar) | XZ_OPT=$${XZ_OPT--e} xz -c >$(distdir).tar.xz + $(am__post_remove_distdir) + +dist-tarZ: distdir + @echo WARNING: "Support for shar distribution archives is" \ + "deprecated." >&2 + @echo WARNING: "It will be removed altogether in Automake 2.0" >&2 + tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z + $(am__post_remove_distdir) + +dist-shar: distdir + @echo WARNING: "Support for distribution archives compressed with" \ + "legacy program 'compress' is deprecated." >&2 + @echo WARNING: "It will be removed altogether in Automake 2.0" >&2 + shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz + $(am__post_remove_distdir) + +dist-zip: distdir + -rm -f $(distdir).zip + zip -rq $(distdir).zip $(distdir) + $(am__post_remove_distdir) + +dist dist-all: + $(MAKE) $(AM_MAKEFLAGS) $(DIST_TARGETS) am__post_remove_distdir='@:' + $(am__post_remove_distdir) + +# This target untars the dist file and tries a VPATH configuration. Then +# it guarantees that the distribution is self-contained by making another +# tarfile. +distcheck: dist + case '$(DIST_ARCHIVES)' in \ + *.tar.gz*) \ + GZIP=$(GZIP_ENV) gzip -dc $(distdir).tar.gz | $(am__untar) ;;\ + *.tar.bz2*) \ + bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\ + *.tar.lz*) \ + lzip -dc $(distdir).tar.lz | $(am__untar) ;;\ + *.tar.xz*) \ + xz -dc $(distdir).tar.xz | $(am__untar) ;;\ + *.tar.Z*) \ + uncompress -c $(distdir).tar.Z | $(am__untar) ;;\ + *.shar.gz*) \ + GZIP=$(GZIP_ENV) gzip -dc $(distdir).shar.gz | unshar ;;\ + *.zip*) \ + unzip $(distdir).zip ;;\ + esac + chmod -R a-w $(distdir) + chmod u+w $(distdir) + mkdir $(distdir)/_build $(distdir)/_inst + chmod a-w $(distdir) + test -d $(distdir)/_build || exit 0; \ + dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \ + && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \ + && am__cwd=`pwd` \ + && $(am__cd) $(distdir)/_build \ + && ../configure \ + $(AM_DISTCHECK_CONFIGURE_FLAGS) \ + $(DISTCHECK_CONFIGURE_FLAGS) \ + --srcdir=.. --prefix="$$dc_install_base" \ + && $(MAKE) $(AM_MAKEFLAGS) \ + && $(MAKE) $(AM_MAKEFLAGS) dvi \ + && $(MAKE) $(AM_MAKEFLAGS) check \ + && $(MAKE) $(AM_MAKEFLAGS) install \ + && $(MAKE) $(AM_MAKEFLAGS) installcheck \ + && $(MAKE) $(AM_MAKEFLAGS) uninstall \ + && $(MAKE) $(AM_MAKEFLAGS) distuninstallcheck_dir="$$dc_install_base" \ + distuninstallcheck \ + && chmod -R a-w "$$dc_install_base" \ + && ({ \ + (cd ../.. && umask 077 && mkdir "$$dc_destdir") \ + && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" install \ + && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" uninstall \ + && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" \ + distuninstallcheck_dir="$$dc_destdir" distuninstallcheck; \ + } || { rm -rf "$$dc_destdir"; exit 1; }) \ + && rm -rf "$$dc_destdir" \ + && $(MAKE) $(AM_MAKEFLAGS) dist \ + && rm -rf $(DIST_ARCHIVES) \ + && $(MAKE) $(AM_MAKEFLAGS) distcleancheck \ + && cd "$$am__cwd" \ + || exit 1 + $(am__post_remove_distdir) + @(echo "$(distdir) archives ready for distribution: "; \ + list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \ + sed -e 1h -e 1s/./=/g -e 1p -e 1x -e '$$p' -e '$$x' +distuninstallcheck: + @test -n '$(distuninstallcheck_dir)' || { \ + echo 'ERROR: trying to run $@ with an empty' \ + '$$(distuninstallcheck_dir)' >&2; \ + exit 1; \ + }; \ + $(am__cd) '$(distuninstallcheck_dir)' || { \ + echo 'ERROR: cannot chdir into $(distuninstallcheck_dir)' >&2; \ + exit 1; \ + }; \ + test `$(am__distuninstallcheck_listfiles) | wc -l` -eq 0 \ + || { echo "ERROR: files left after uninstall:" ; \ + if test -n "$(DESTDIR)"; then \ + echo " (check DESTDIR support)"; \ + fi ; \ + $(distuninstallcheck_listfiles) ; \ + exit 1; } >&2 +distcleancheck: distclean + @if test '$(srcdir)' = . ; then \ + echo "ERROR: distcleancheck can only run from a VPATH build" ; \ + exit 1 ; \ + fi + @test `$(distcleancheck_listfiles) | wc -l` -eq 0 \ + || { echo "ERROR: files left in build directory after distclean:" ; \ + $(distcleancheck_listfiles) ; \ + exit 1; } >&2 +check-am: all-am +check: check-recursive +all-am: Makefile config.h +installdirs: installdirs-recursive +installdirs-am: +install: install-recursive +install-exec: install-exec-recursive +install-data: install-data-recursive +uninstall: uninstall-recursive + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-recursive +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-recursive + +clean-am: clean-generic clean-libtool mostlyclean-am + +distclean: distclean-recursive + -rm -f $(am__CONFIG_DISTCLEAN_FILES) + -rm -f Makefile +distclean-am: clean-am distclean-generic distclean-hdr \ + distclean-libtool distclean-tags + +dvi: dvi-recursive + +dvi-am: + +html: html-recursive + +html-am: + +info: info-recursive + +info-am: + +install-data-am: + +install-dvi: install-dvi-recursive + +install-dvi-am: + +install-exec-am: + +install-html: install-html-recursive + +install-html-am: + +install-info: install-info-recursive + +install-info-am: + +install-man: + +install-pdf: install-pdf-recursive + +install-pdf-am: + +install-ps: install-ps-recursive + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-recursive + -rm -f $(am__CONFIG_DISTCLEAN_FILES) + -rm -rf $(top_srcdir)/autom4te.cache + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-recursive + +mostlyclean-am: mostlyclean-generic mostlyclean-libtool + +pdf: pdf-recursive + +pdf-am: + +ps: ps-recursive + +ps-am: + +uninstall-am: + +.MAKE: $(am__recursive_targets) all install-am install-strip + +.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \ + am--refresh check check-am clean clean-cscope clean-generic \ + clean-libtool cscope cscopelist-am ctags ctags-am dist \ + dist-all dist-bzip2 dist-gzip dist-lzip dist-shar dist-tarZ \ + dist-xz dist-zip distcheck distclean distclean-generic \ + distclean-hdr distclean-libtool distclean-tags distcleancheck \ + distdir distuninstallcheck dvi dvi-am html html-am info \ + info-am install install-am install-data install-data-am \ + install-dvi install-dvi-am install-exec install-exec-am \ + install-html install-html-am install-info install-info-am \ + install-man install-pdf install-pdf-am install-ps \ + install-ps-am install-strip installcheck installcheck-am \ + installdirs installdirs-am maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-generic \ + mostlyclean-libtool pdf pdf-am ps ps-am tags tags-am uninstall \ + uninstall-am + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/NEWS b/native_client/ctcdecode/third_party/openfst-1.6.7/NEWS new file mode 100644 index 0000000000..c798899fe3 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/NEWS @@ -0,0 +1,247 @@ +OpenFst: Release 1.6 + * The `first_path` option to ShortestPath is now optimal for A* (1.6.7) + * Renames SymbolTable::kNoSymbol to kNoSymbol (1.6.7) + * Exposes PowerMapper to the scripting API (1.6.7) + * Fixes linking of the special SOs (1.6.7) + * Fixes error handling in HashMatcher (1.6.6) + * Adds kShortestDelta for operations dependent on shortest-distance (1.6.6) + * Adds Python methods for (un)pickling and (de)serializing FSTs (1.6.6) + * Adds constructive variants of Invert and Project (1.6.6) + * Increases code sharing in MemoryPool/MemoryArena (1.6.6) + * Improves consistency of matcher FST ownership (1.6.6) + * Adds non-trivial A* estimator class (1.6.6) + * Prevents unreachable code generation in libfstscript (1.6.5) + * Adds move constructors for non-trivial weight types (1.6.5) + * Standardizes method names for tuple weight types (1.6.5) + * Eliminates undefined behavior in weight hashing (1.6.5) + * Optimizes binary search in SortedMatcher (1.6.5) + * Adds SetWeight (1.6.5) + * Fixes typing error in Python FAR reader (1.6.4) + * Removes restriction that Prune argument have commutative weights (1.6.3) + * Improves configuration of CompositeWeight readers and writers (1.6.3) + * Improves accuracy of ShortestDistance summation (1.6.3) + * SetFinal now "moves" its weight argument (1.6.3) + * Exposes ArcIterator and EncodeMapper flags in Python (1.6.3) + * Properly sets return codes in FST binaries (1.6.3) + * Eliminates StringWeight macros (1.6.3) + * Finalizes most virtual method overrides (1.6.2) + * Fixes missing includes of (1.6.1) + * Adds float format support to FST drawing (1.6.1) + * Extensive modernization for C++11 style (1.6.0) + * Many classes and constants moved into an internal namespace (1.6.0) + * Adds HashMatcher (1.6.0) + * Adds Member method to SymbolTable (1.6.0) + * Adds the "special" extension and the fstspecial binary; this is similar to + fstconvert but accepts arguments for specifying special labels (phi, rho, + and sigma) of FSTs (1.6.0) + * Exposes allow_negative_label option for Python symbol tables (1.6.0) + +OpenFst: Release 1.5 + * Added p-subsequential determinization (1.5.0) + * Generalized epsilon normalization to non-functional case (1.5.0) + * Added general gallic (plus is union) semiring (1.5.0) + * Added FST compression extension (1.5.0) + * Added Python extension (1.5.0) + * Added multiple pushdown transducer (MPDT) support (1.5.0) + * Fixed Isomorphic function (1.5.0) + * Added final method to matchers (1.5.0) + * Fixed various compiler issues (1.5.0) + * Fixed missing Isomorphic components (1.5.0) + * Added UnionWeight (1.5.0) + * Added InputEpsilonMapper and OutputEpsilonMapper arc mappers (1.5.1) + * Added TrivialComposeFilter for more efficient composition when one + of the arguments is epsilon-free (1.5.1) + * Added properties bits kUnweightedCycles and kWeightedCycles (1.5.1) + * Added missing const qualification to (1.5.1): + - SymbolTableIterator access + - EncodeMapper writing to file + - EncodeMapper SymbolTable access + * Replaced internal custom reference-counting (RefCounter) with + C++11 smart pointers where possible, and fixed associated + reference-counting bugs (1.5.1) + * When calling DeleteStates on a MutableFst with a shared impl, the impl + is set to a new empty impl rather than copying and deleting (1.5.1) + * Prepended `Pdt` to the Expand libraries and classes in the PDT + extension, and prepended `MPdt` to the Expand libraries and classes + in the MPDT extension, so that both can be used in the same compilation + unit (1.5.1) + * Added option to PDT Replace for compiling a strongly-regular RTN into a + bounded-stack PDT (1.5.1) + * Improved symbol table support for PDT Replace, including automatic + generation of parentheses symbols (1.5.1) + * Improvements to scripting API (1.5.1): + - Added methods for FST access and mutation + - Added additional checks for arc/weight compatibility + - WeightClass::One and WeightClass::Zero now require a specified weight + type at time of construction + - Improved VectorFstClass constructors + - Added linear-time check for cyclic dependencies in Replace + - Added EncodeMapperClass, a template-free box for an EncodeMapper + * Improvements to the binaries (1.5.1): + - Fixed no-op --precision flag to fstdraw (1.5.1) + - Fixed no-op --file_list_input flag to farcreate (1.5.1) + * Improvements to the Python extension (1.5.1): + - Added methods for creating an empty mutable FST + - Added methods for FST access via state and arc iteration + - Added FST compilation from arclists (cf. fstcompile) + - Added FST printing and drawing + - Added FarReader and FarWriter classes. + * FarReader's GetFst method now returns a pointer (1.5.2) + * Fixed FSTERROR macro (1.5.2) + * Fixed build flags for dlopen (1.5.2) + * Consolidated Python extension into single module (1.5.2) + * Python add_arc now takes an Arc object (1.5.2) + * Adds optional minimization of non-deterministic FSTs (1.5.3) + * Mutation methods of the Python Fst object now support chaining (1.5.3) + * Scripting API and Python weight objects now support semiring arithmetic + (1.5.3) + * Adds RemoveSymbol method to SymbolTable (1.5.4) + * Prevents underflow when using LogProbArcSelector in random generation + (1.5.4) + * Makes random weight generators a single template class (1.5.4) + * Makes weight Properties constexpr where possible (1.5.4) + * Adds check for error when opening files when compiling strings into FARs + (1.5.4) + * Adds routines for parsing string flags to the scripting API (1.5.4) + +OpenFst: Release 1.4 + * Port to C++11 (1.4.0) + * Disambiguate function added (1.4.0) + * Isomorphic function added (1.4.0) + * Matcher interface augmented with Priority method. + * Special matchers (rho/sigma/phi) can match special symbols + on both input FSTs in composition/intersection provided at each + state pair they only match one side (1.4.0) + * Added ExplicitMatcher to suppress implicit matches (e.g. epsilon + self-loops) (1.4.0) + * Linear{Tagger,Classifier}Fst extensions added (1.4.0). + * Generalized state-reachable to work when input is cyclic (so long as no + final state is in a cycle). This ensures label-reachable (and hence label + lookahead) works with cyclic input (1.4.0) + * Added Condense to build the condensation graph (SCCs condensed to single + states) of an FST (1.4.0). + * Added an option to Reverse to specify whether a super-initial state + should always be created (1.4.0). + * Fixed bugs in FirstCacheStore, PowerWeight, and StringCompiler (1.4.0). + * Changed SymbolTable to use faster data structure (1.4.0). + * Added 'min' disambiguation in determinizaton to keep only the minimum + output in a non-functional transducer when plus=min/max + (flag --disambiguate_output) (1.4.1) + * Compiler issues in linear-fst fixed (1.4.1) + +OpenFst: Release 1.3 + * Support for non-fatal exits on errors: (1.3.1) + - Added FLAGS_fst_error_fatal: FST errors are + fatal if true (default); o.w. return objects flagged as bad: + e.g., FSTs - kError + prop. true, FST weights - not a Member(). + - Added kError property bit signifying bad FST + - Added NoWeight() method to FST weight requirements that returns + weight that is not a Member(). + * Various improvements to the FAR extensions (1.3.1) + - a single FST is now a FAR type + - FLAGS_initial_symbols: Uses the symbol table from the + first FST in the archive for all entries" + - Input/output to standard input/output for some FAR and arc types + * --with-icu configuration option no longer needed (1.3.1) + * Improved flags usage esp. if use SET_FLAGS not SetFlags/InitFst (1.3.2) + * Added 'fst' as possible far writer type (1.3.2) + * phi matcher can now accept 0 as the phi label (1.3.2) + * Added ngram-fst extension (1.3.2) + * Improved performance of PDT composition (1.3.3) + * Memory-map support (1.3.3) + * Fixed cross-FST serialization issues (1.3.3) + * Fixed NGramFst off-by-one issue (1.3.3) + * farextract now allows one to specify a list of comma-separated keys, + including key ranges (1.3.3) + * Fixed bug in PDT replace that could cause close paren IDs to collide + with open paren IDs (1.3.4) + +OpenFst: Release 1.2 + * Added lookahead matching and filtering for faster composition + * Added EditFst for mutation of o.w. immutable FSTs + * Added script sub-namespace defining type FstClass, a non-templated + Fst to hold the arc template type internally. This and FST + operations on it allow easier I/O and scripting at the cost of some + runtime dispatching. + * Added per-arc-iterator control of Fst caching. + * Added PowerWeight and Power Arc. + * Added SparsePowerWeight and SparsePowerArc (1.2.4) + * Added SignedLogWeight and SignedLogArc (1.2.4) + * Added ExpectationWeight and ExpectationArc (1.2.4) + * Added AStarQueue, PruneQueue and NaturalPruneQueue disciplines (1.2.6) + * Added Log64Weight and Log64Arc to FST library throughout, including + support throughout scripts/bins/dsos (1.2.8) + * Added delayed RandGenFst that outputs tree of paths weighted + by count (1.2.8) + * Added fstsymbols shell-level command + * Added total weight removal option to pushing + * Changed methods for symbol table mutation: + use MutableInputSymbols()/MutableOutputSymbols(). + * Numerous efficiency improvements esp in composition, replace, and caching + * Made "fstmap" handle semiring conversion by adding "to_std", "to_log" + and "to_log64" as supported 'map_type' arguments (1.2.8). + * Made the destructive implementation of RmEpsilon skip over states + admitting no non-epsilon incoming transition (1.2.8). + * Fixed numerous bugs (1.2 through 1.2.9) including: + - improper types of some approximation deltas + - sub-optimal hashing functions + - issues in internal reuse of shortest distance + - hashing bug in FloatWeight + - bug in shortest path queue + - symbol table checksumming issues + - various C++ standards issues + - Visit() behavior when visitation aborted + - Decode() hash performance bug (1.2.1) + - EditFst::Copy(bool) method when the boolean parameter is true (1.2.7) + - SymbolTable memory leak in Invert() (1.2.8) + - Added escaping of " and \ in labels in fstdraw, needed for dot to + function properly (1.2.8) + - Fixed handling of final weight of start state in fstpush (1.2.8) + - Added FST_LL_FORMAT to fix 64-bit integer printf issues (1.2.9) + - Fixed missing includes (1.2.9) + - Fixed reused local variable names (1.2.9) + - Fixed passing string by reference in FstDraw args (1.2.9) + * Added extensions directories including: + - finite-state archive (FAR) utilities, + added stlist format supporting writing/reading to/from standard out/in + at the library-level (1.2.8) + - compact fsts + - lookahead fsts + - pushdown transducers (improved in 1.2.1 through 1.2.7). + * Added StateMap/StateMapFst; renamed Map/MapFst to ArcMap/ArcMapFst; + map/MapFst retained (but deprecated) (1.2.9) + * Deleted ArcSum() and ArcMerge; use StateMap w/ ArcSumMapper and + ArcUniqueMapper (1.2.9). + * Incremented version of ConstFst/CompactFsts to stop memory alignment + that fails on pipes. Made old version raises errors when read on + pipes (1.2.9). + * Improved determinize hash (1.2.9) + * Removed stdio uses (1.2.10) + * Fixed library ordering issues esp. with newer GNU build tools (1.2.10) + +OpenFst: Release 1.1 + * Added compat.h to src/include/fst to fix missing defines + * Fixed bug in acyclic minimization that led to non-minimal + (but equivalent) results + * Fixed missing FST typedef in various matchers in matcher.h + so that they can be cascaded + * Opened file streams binary where appropriate + +OpenFst: Release 1.0 (Additions to beta version): + * Matcher class added for matching labels at FST states. Includes + special matchers for sigma (any), rho ('rest'), and phi ('fail') + labels. + * Composition generalized with arbitrary filters, matchers, and state + tables. + * Sequence and matching composition filters provided. (see compose.h, + compose-filter.h, matcher.h, state-table.h) + * Unique n-best (see shortest-path.h) + * Pruning in determinization and epsilon removal (see determinize.h, + rmepsilon.h) + * New Fst class: + * Compact Fsts for space-efficient representation (see compact-fst.h) + * New Weight classes: + * MinMax + * Lexicographic + * Miscellaneous bug fixes diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/README b/native_client/ctcdecode/third_party/openfst-1.6.7/README new file mode 100644 index 0000000000..fe7aa5ef38 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/README @@ -0,0 +1,66 @@ +OpenFst: Release 1.6.7. + +OpenFst is a library for constructing, combining, optimizing, and searching +weighted finite-state transducers (FSTs). + +REQUIREMENTS: + This version is known to work under Linux using g++ (>= 4.7) and OS X using + XCode (>= 5). It is expected to work wherever adequate POSIX (dlopen, + ssize_t, basename), C99 (snprintf, strtoll, ), and C++11 + (, , ) support is available. + +INSTALLATION: + Follow the generic GNU build system instructions in ./INSTALL. We + recommend configuring with --enable-static=no for faster compiles. + + Optional features: + + --enable-bin Enable fst::script and executables (def: yes) + --enable-compact-fsts Enable CompactFst extensions (def: no) + --enable-compress Enable compression extension (def: no) + --enable-const-fsts Enable ConstFst extensions (def: no) + --enable-far Enable FAR extensions (def: no) + --enable-grm Enable all dependencies of OpenGrm (def: no) + --enable-linear-fsts Enable LinearTagger/ClassifierFst extensions (def: no) + --enable-lookahead-fsts Enable LookAheadFst extensions (def: no) + --enable-mpdt Enable MPDT extensions (def: no) + --enable-ngram-fsts Enable NGramFst extensions (def: no) + --enable-pdt Enable PDT extensions (def: no) + --enable-python Enable Python extension (def: no) + --enable-special Enable special-matcher extensions (def: no) + + Configuring with --enable-bin=no gives very fast compiles, but excludes the + command line utilities. + + Configuring with --enable-python will attempt to install the Python module to + whichever site-packages (or dist-packages, on Debian or Ubuntu) is found + during configuration. + + The flag --with-libfstdir specifies where FST extensions should be installed; + it defaults to ${libdir}/fst. + + Compiling with -Wall -Wno-sign-compare under g++ should give no warnings from + this library. + + If you encounter an error about loading shared objects when attempting to use + the library immediately after installation, (e.g, `...cannot open shared + object file...`) you may need to refresh your system's shared object cache. + On Linux, this is accomplished by invoking ldconfig; the corresponding command + on OS X is called update_dyld_shared_cache. Both of these require superuser + privileges (and so should be executed with sudo). + +USAGE: + Assuming you've installed under the default /usr/local, the FST binaries are + found on /usr/local/bin. + + To use in your own program, include and compile with + -I/usr/local/include. The compiler must support C++11 (for g++ add the flag + -std=c++11). Link against /usr/local/lib/libfst.so and -ldl. Set your + LD_LIBRARY_PATH (or equivalent) to contain /usr/local/lib. The linking is, + by default, dynamic so that the Fst and Arc type DSO extensions can be used + correctly if desired. Any extensions will be found under /usr/local/lib/fst + or /usr/local/include/fst/extensions. + +DOCUMENTATION: + See www.openfst.org for general documentation. + See ./NEWS for updates since the last release. diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/aclocal.m4 b/native_client/ctcdecode/third_party/openfst-1.6.7/aclocal.m4 new file mode 100644 index 0000000000..3b1905b23c --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/aclocal.m4 @@ -0,0 +1,1450 @@ +# generated automatically by aclocal 1.14.1 -*- Autoconf -*- + +# Copyright (C) 1996-2013 Free Software Foundation, Inc. + +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])]) +m4_ifndef([AC_AUTOCONF_VERSION], + [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl +m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.69],, +[m4_warning([this file was generated for autoconf 2.69. +You have another version of autoconf. It may work, but is not guaranteed to. +If you have problems, you may need to regenerate the build system entirely. +To do so, use the procedure documented by the package, typically 'autoreconf'.])]) + +# Copyright (C) 2002-2013 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_AUTOMAKE_VERSION(VERSION) +# ---------------------------- +# Automake X.Y traces this macro to ensure aclocal.m4 has been +# generated from the m4 files accompanying Automake X.Y. +# (This private macro should not be called outside this file.) +AC_DEFUN([AM_AUTOMAKE_VERSION], +[am__api_version='1.14' +dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to +dnl require some minimum version. Point them to the right macro. +m4_if([$1], [1.14.1], [], + [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl +]) + +# _AM_AUTOCONF_VERSION(VERSION) +# ----------------------------- +# aclocal traces this macro to find the Autoconf version. +# This is a private macro too. Using m4_define simplifies +# the logic in aclocal, which can simply ignore this definition. +m4_define([_AM_AUTOCONF_VERSION], []) + +# AM_SET_CURRENT_AUTOMAKE_VERSION +# ------------------------------- +# Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced. +# This function is AC_REQUIREd by AM_INIT_AUTOMAKE. +AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION], +[AM_AUTOMAKE_VERSION([1.14.1])dnl +m4_ifndef([AC_AUTOCONF_VERSION], + [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl +_AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))]) + +# Copyright (C) 2011-2013 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_PROG_AR([ACT-IF-FAIL]) +# ------------------------- +# Try to determine the archiver interface, and trigger the ar-lib wrapper +# if it is needed. If the detection of archiver interface fails, run +# ACT-IF-FAIL (default is to abort configure with a proper error message). +AC_DEFUN([AM_PROG_AR], +[AC_BEFORE([$0], [LT_INIT])dnl +AC_BEFORE([$0], [AC_PROG_LIBTOOL])dnl +AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl +AC_REQUIRE_AUX_FILE([ar-lib])dnl +AC_CHECK_TOOLS([AR], [ar lib "link -lib"], [false]) +: ${AR=ar} + +AC_CACHE_CHECK([the archiver ($AR) interface], [am_cv_ar_interface], + [AC_LANG_PUSH([C]) + am_cv_ar_interface=ar + AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int some_variable = 0;]])], + [am_ar_try='$AR cru libconftest.a conftest.$ac_objext >&AS_MESSAGE_LOG_FD' + AC_TRY_EVAL([am_ar_try]) + if test "$ac_status" -eq 0; then + am_cv_ar_interface=ar + else + am_ar_try='$AR -NOLOGO -OUT:conftest.lib conftest.$ac_objext >&AS_MESSAGE_LOG_FD' + AC_TRY_EVAL([am_ar_try]) + if test "$ac_status" -eq 0; then + am_cv_ar_interface=lib + else + am_cv_ar_interface=unknown + fi + fi + rm -f conftest.lib libconftest.a + ]) + AC_LANG_POP([C])]) + +case $am_cv_ar_interface in +ar) + ;; +lib) + # Microsoft lib, so override with the ar-lib wrapper script. + # FIXME: It is wrong to rewrite AR. + # But if we don't then we get into trouble of one sort or another. + # A longer-term fix would be to have automake use am__AR in this case, + # and then we could set am__AR="$am_aux_dir/ar-lib \$(AR)" or something + # similar. + AR="$am_aux_dir/ar-lib $AR" + ;; +unknown) + m4_default([$1], + [AC_MSG_ERROR([could not determine $AR interface])]) + ;; +esac +AC_SUBST([AR])dnl +]) + +# AM_AUX_DIR_EXPAND -*- Autoconf -*- + +# Copyright (C) 2001-2013 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets +# $ac_aux_dir to '$srcdir/foo'. In other projects, it is set to +# '$srcdir', '$srcdir/..', or '$srcdir/../..'. +# +# Of course, Automake must honor this variable whenever it calls a +# tool from the auxiliary directory. The problem is that $srcdir (and +# therefore $ac_aux_dir as well) can be either absolute or relative, +# depending on how configure is run. This is pretty annoying, since +# it makes $ac_aux_dir quite unusable in subdirectories: in the top +# source directory, any form will work fine, but in subdirectories a +# relative path needs to be adjusted first. +# +# $ac_aux_dir/missing +# fails when called from a subdirectory if $ac_aux_dir is relative +# $top_srcdir/$ac_aux_dir/missing +# fails if $ac_aux_dir is absolute, +# fails when called from a subdirectory in a VPATH build with +# a relative $ac_aux_dir +# +# The reason of the latter failure is that $top_srcdir and $ac_aux_dir +# are both prefixed by $srcdir. In an in-source build this is usually +# harmless because $srcdir is '.', but things will broke when you +# start a VPATH build or use an absolute $srcdir. +# +# So we could use something similar to $top_srcdir/$ac_aux_dir/missing, +# iff we strip the leading $srcdir from $ac_aux_dir. That would be: +# am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"` +# and then we would define $MISSING as +# MISSING="\${SHELL} $am_aux_dir/missing" +# This will work as long as MISSING is not called from configure, because +# unfortunately $(top_srcdir) has no meaning in configure. +# However there are other variables, like CC, which are often used in +# configure, and could therefore not use this "fixed" $ac_aux_dir. +# +# Another solution, used here, is to always expand $ac_aux_dir to an +# absolute PATH. The drawback is that using absolute paths prevent a +# configured tree to be moved without reconfiguration. + +AC_DEFUN([AM_AUX_DIR_EXPAND], +[dnl Rely on autoconf to set up CDPATH properly. +AC_PREREQ([2.50])dnl +# expand $ac_aux_dir to an absolute path +am_aux_dir=`cd $ac_aux_dir && pwd` +]) + +# AM_CONDITIONAL -*- Autoconf -*- + +# Copyright (C) 1997-2013 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_CONDITIONAL(NAME, SHELL-CONDITION) +# ------------------------------------- +# Define a conditional. +AC_DEFUN([AM_CONDITIONAL], +[AC_PREREQ([2.52])dnl + m4_if([$1], [TRUE], [AC_FATAL([$0: invalid condition: $1])], + [$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl +AC_SUBST([$1_TRUE])dnl +AC_SUBST([$1_FALSE])dnl +_AM_SUBST_NOTMAKE([$1_TRUE])dnl +_AM_SUBST_NOTMAKE([$1_FALSE])dnl +m4_define([_AM_COND_VALUE_$1], [$2])dnl +if $2; then + $1_TRUE= + $1_FALSE='#' +else + $1_TRUE='#' + $1_FALSE= +fi +AC_CONFIG_COMMANDS_PRE( +[if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then + AC_MSG_ERROR([[conditional "$1" was never defined. +Usually this means the macro was only invoked conditionally.]]) +fi])]) + +# Copyright (C) 1999-2013 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + + +# There are a few dirty hacks below to avoid letting 'AC_PROG_CC' be +# written in clear, in which case automake, when reading aclocal.m4, +# will think it sees a *use*, and therefore will trigger all it's +# C support machinery. Also note that it means that autoscan, seeing +# CC etc. in the Makefile, will ask for an AC_PROG_CC use... + + +# _AM_DEPENDENCIES(NAME) +# ---------------------- +# See how the compiler implements dependency checking. +# NAME is "CC", "CXX", "OBJC", "OBJCXX", "UPC", or "GJC". +# We try a few techniques and use that to set a single cache variable. +# +# We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was +# modified to invoke _AM_DEPENDENCIES(CC); we would have a circular +# dependency, and given that the user is not expected to run this macro, +# just rely on AC_PROG_CC. +AC_DEFUN([_AM_DEPENDENCIES], +[AC_REQUIRE([AM_SET_DEPDIR])dnl +AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl +AC_REQUIRE([AM_MAKE_INCLUDE])dnl +AC_REQUIRE([AM_DEP_TRACK])dnl + +m4_if([$1], [CC], [depcc="$CC" am_compiler_list=], + [$1], [CXX], [depcc="$CXX" am_compiler_list=], + [$1], [OBJC], [depcc="$OBJC" am_compiler_list='gcc3 gcc'], + [$1], [OBJCXX], [depcc="$OBJCXX" am_compiler_list='gcc3 gcc'], + [$1], [UPC], [depcc="$UPC" am_compiler_list=], + [$1], [GCJ], [depcc="$GCJ" am_compiler_list='gcc3 gcc'], + [depcc="$$1" am_compiler_list=]) + +AC_CACHE_CHECK([dependency style of $depcc], + [am_cv_$1_dependencies_compiler_type], +[if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then + # We make a subdir and do the tests there. Otherwise we can end up + # making bogus files that we don't know about and never remove. For + # instance it was reported that on HP-UX the gcc test will end up + # making a dummy file named 'D' -- because '-MD' means "put the output + # in D". + rm -rf conftest.dir + mkdir conftest.dir + # Copy depcomp to subdir because otherwise we won't find it if we're + # using a relative directory. + cp "$am_depcomp" conftest.dir + cd conftest.dir + # We will build objects and dependencies in a subdirectory because + # it helps to detect inapplicable dependency modes. For instance + # both Tru64's cc and ICC support -MD to output dependencies as a + # side effect of compilation, but ICC will put the dependencies in + # the current directory while Tru64 will put them in the object + # directory. + mkdir sub + + am_cv_$1_dependencies_compiler_type=none + if test "$am_compiler_list" = ""; then + am_compiler_list=`sed -n ['s/^#*\([a-zA-Z0-9]*\))$/\1/p'] < ./depcomp` + fi + am__universal=false + m4_case([$1], [CC], + [case " $depcc " in #( + *\ -arch\ *\ -arch\ *) am__universal=true ;; + esac], + [CXX], + [case " $depcc " in #( + *\ -arch\ *\ -arch\ *) am__universal=true ;; + esac]) + + for depmode in $am_compiler_list; do + # Setup a source with many dependencies, because some compilers + # like to wrap large dependency lists on column 80 (with \), and + # we should not choose a depcomp mode which is confused by this. + # + # We need to recreate these files for each test, as the compiler may + # overwrite some of them when testing with obscure command lines. + # This happens at least with the AIX C compiler. + : > sub/conftest.c + for i in 1 2 3 4 5 6; do + echo '#include "conftst'$i'.h"' >> sub/conftest.c + # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with + # Solaris 10 /bin/sh. + echo '/* dummy */' > sub/conftst$i.h + done + echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf + + # We check with '-c' and '-o' for the sake of the "dashmstdout" + # mode. It turns out that the SunPro C++ compiler does not properly + # handle '-M -o', and we need to detect this. Also, some Intel + # versions had trouble with output in subdirs. + am__obj=sub/conftest.${OBJEXT-o} + am__minus_obj="-o $am__obj" + case $depmode in + gcc) + # This depmode causes a compiler race in universal mode. + test "$am__universal" = false || continue + ;; + nosideeffect) + # After this tag, mechanisms are not by side-effect, so they'll + # only be used when explicitly requested. + if test "x$enable_dependency_tracking" = xyes; then + continue + else + break + fi + ;; + msvc7 | msvc7msys | msvisualcpp | msvcmsys) + # This compiler won't grok '-c -o', but also, the minuso test has + # not run yet. These depmodes are late enough in the game, and + # so weak that their functioning should not be impacted. + am__obj=conftest.${OBJEXT-o} + am__minus_obj= + ;; + none) break ;; + esac + if depmode=$depmode \ + source=sub/conftest.c object=$am__obj \ + depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ + $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \ + >/dev/null 2>conftest.err && + grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && + grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && + grep $am__obj sub/conftest.Po > /dev/null 2>&1 && + ${MAKE-make} -s -f confmf > /dev/null 2>&1; then + # icc doesn't choke on unknown options, it will just issue warnings + # or remarks (even with -Werror). So we grep stderr for any message + # that says an option was ignored or not supported. + # When given -MP, icc 7.0 and 7.1 complain thusly: + # icc: Command line warning: ignoring option '-M'; no argument required + # The diagnosis changed in icc 8.0: + # icc: Command line remark: option '-MP' not supported + if (grep 'ignoring option' conftest.err || + grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else + am_cv_$1_dependencies_compiler_type=$depmode + break + fi + fi + done + + cd .. + rm -rf conftest.dir +else + am_cv_$1_dependencies_compiler_type=none +fi +]) +AC_SUBST([$1DEPMODE], [depmode=$am_cv_$1_dependencies_compiler_type]) +AM_CONDITIONAL([am__fastdep$1], [ + test "x$enable_dependency_tracking" != xno \ + && test "$am_cv_$1_dependencies_compiler_type" = gcc3]) +]) + + +# AM_SET_DEPDIR +# ------------- +# Choose a directory name for dependency files. +# This macro is AC_REQUIREd in _AM_DEPENDENCIES. +AC_DEFUN([AM_SET_DEPDIR], +[AC_REQUIRE([AM_SET_LEADING_DOT])dnl +AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl +]) + + +# AM_DEP_TRACK +# ------------ +AC_DEFUN([AM_DEP_TRACK], +[AC_ARG_ENABLE([dependency-tracking], [dnl +AS_HELP_STRING( + [--enable-dependency-tracking], + [do not reject slow dependency extractors]) +AS_HELP_STRING( + [--disable-dependency-tracking], + [speeds up one-time build])]) +if test "x$enable_dependency_tracking" != xno; then + am_depcomp="$ac_aux_dir/depcomp" + AMDEPBACKSLASH='\' + am__nodep='_no' +fi +AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno]) +AC_SUBST([AMDEPBACKSLASH])dnl +_AM_SUBST_NOTMAKE([AMDEPBACKSLASH])dnl +AC_SUBST([am__nodep])dnl +_AM_SUBST_NOTMAKE([am__nodep])dnl +]) + +# Generate code to set up dependency tracking. -*- Autoconf -*- + +# Copyright (C) 1999-2013 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + + +# _AM_OUTPUT_DEPENDENCY_COMMANDS +# ------------------------------ +AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS], +[{ + # Older Autoconf quotes --file arguments for eval, but not when files + # are listed without --file. Let's play safe and only enable the eval + # if we detect the quoting. + case $CONFIG_FILES in + *\'*) eval set x "$CONFIG_FILES" ;; + *) set x $CONFIG_FILES ;; + esac + shift + for mf + do + # Strip MF so we end up with the name of the file. + mf=`echo "$mf" | sed -e 's/:.*$//'` + # Check whether this is an Automake generated Makefile or not. + # We used to match only the files named 'Makefile.in', but + # some people rename them; so instead we look at the file content. + # Grep'ing the first line is not enough: some people post-process + # each Makefile.in and add a new line on top of each file to say so. + # Grep'ing the whole file is not good either: AIX grep has a line + # limit of 2048, but all sed's we know have understand at least 4000. + if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then + dirpart=`AS_DIRNAME("$mf")` + else + continue + fi + # Extract the definition of DEPDIR, am__include, and am__quote + # from the Makefile without running 'make'. + DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"` + test -z "$DEPDIR" && continue + am__include=`sed -n 's/^am__include = //p' < "$mf"` + test -z "$am__include" && continue + am__quote=`sed -n 's/^am__quote = //p' < "$mf"` + # Find all dependency output files, they are included files with + # $(DEPDIR) in their names. We invoke sed twice because it is the + # simplest approach to changing $(DEPDIR) to its actual value in the + # expansion. + for file in `sed -n " + s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \ + sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do + # Make sure the directory exists. + test -f "$dirpart/$file" && continue + fdir=`AS_DIRNAME(["$file"])` + AS_MKDIR_P([$dirpart/$fdir]) + # echo "creating $dirpart/$file" + echo '# dummy' > "$dirpart/$file" + done + done +} +])# _AM_OUTPUT_DEPENDENCY_COMMANDS + + +# AM_OUTPUT_DEPENDENCY_COMMANDS +# ----------------------------- +# This macro should only be invoked once -- use via AC_REQUIRE. +# +# This code is only required when automatic dependency tracking +# is enabled. FIXME. This creates each '.P' file that we will +# need in order to bootstrap the dependency handling code. +AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS], +[AC_CONFIG_COMMANDS([depfiles], + [test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS], + [AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"]) +]) + +# Do all the work for Automake. -*- Autoconf -*- + +# Copyright (C) 1996-2013 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This macro actually does too much. Some checks are only needed if +# your package does certain things. But this isn't really a big deal. + +dnl Redefine AC_PROG_CC to automatically invoke _AM_PROG_CC_C_O. +m4_define([AC_PROG_CC], +m4_defn([AC_PROG_CC]) +[_AM_PROG_CC_C_O +]) + +# AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE]) +# AM_INIT_AUTOMAKE([OPTIONS]) +# ----------------------------------------------- +# The call with PACKAGE and VERSION arguments is the old style +# call (pre autoconf-2.50), which is being phased out. PACKAGE +# and VERSION should now be passed to AC_INIT and removed from +# the call to AM_INIT_AUTOMAKE. +# We support both call styles for the transition. After +# the next Automake release, Autoconf can make the AC_INIT +# arguments mandatory, and then we can depend on a new Autoconf +# release and drop the old call support. +AC_DEFUN([AM_INIT_AUTOMAKE], +[AC_PREREQ([2.65])dnl +dnl Autoconf wants to disallow AM_ names. We explicitly allow +dnl the ones we care about. +m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl +AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl +AC_REQUIRE([AC_PROG_INSTALL])dnl +if test "`cd $srcdir && pwd`" != "`pwd`"; then + # Use -I$(srcdir) only when $(srcdir) != ., so that make's output + # is not polluted with repeated "-I." + AC_SUBST([am__isrc], [' -I$(srcdir)'])_AM_SUBST_NOTMAKE([am__isrc])dnl + # test to see if srcdir already configured + if test -f $srcdir/config.status; then + AC_MSG_ERROR([source directory already configured; run "make distclean" there first]) + fi +fi + +# test whether we have cygpath +if test -z "$CYGPATH_W"; then + if (cygpath --version) >/dev/null 2>/dev/null; then + CYGPATH_W='cygpath -w' + else + CYGPATH_W=echo + fi +fi +AC_SUBST([CYGPATH_W]) + +# Define the identity of the package. +dnl Distinguish between old-style and new-style calls. +m4_ifval([$2], +[AC_DIAGNOSE([obsolete], + [$0: two- and three-arguments forms are deprecated.]) +m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl + AC_SUBST([PACKAGE], [$1])dnl + AC_SUBST([VERSION], [$2])], +[_AM_SET_OPTIONS([$1])dnl +dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT. +m4_if( + m4_ifdef([AC_PACKAGE_NAME], [ok]):m4_ifdef([AC_PACKAGE_VERSION], [ok]), + [ok:ok],, + [m4_fatal([AC_INIT should be called with package and version arguments])])dnl + AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl + AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl + +_AM_IF_OPTION([no-define],, +[AC_DEFINE_UNQUOTED([PACKAGE], ["$PACKAGE"], [Name of package]) + AC_DEFINE_UNQUOTED([VERSION], ["$VERSION"], [Version number of package])])dnl + +# Some tools Automake needs. +AC_REQUIRE([AM_SANITY_CHECK])dnl +AC_REQUIRE([AC_ARG_PROGRAM])dnl +AM_MISSING_PROG([ACLOCAL], [aclocal-${am__api_version}]) +AM_MISSING_PROG([AUTOCONF], [autoconf]) +AM_MISSING_PROG([AUTOMAKE], [automake-${am__api_version}]) +AM_MISSING_PROG([AUTOHEADER], [autoheader]) +AM_MISSING_PROG([MAKEINFO], [makeinfo]) +AC_REQUIRE([AM_PROG_INSTALL_SH])dnl +AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl +AC_REQUIRE([AC_PROG_MKDIR_P])dnl +# For better backward compatibility. To be removed once Automake 1.9.x +# dies out for good. For more background, see: +# +# +AC_SUBST([mkdir_p], ['$(MKDIR_P)']) +# We need awk for the "check" target. The system "awk" is bad on +# some platforms. +AC_REQUIRE([AC_PROG_AWK])dnl +AC_REQUIRE([AC_PROG_MAKE_SET])dnl +AC_REQUIRE([AM_SET_LEADING_DOT])dnl +_AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])], + [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])], + [_AM_PROG_TAR([v7])])]) +_AM_IF_OPTION([no-dependencies],, +[AC_PROVIDE_IFELSE([AC_PROG_CC], + [_AM_DEPENDENCIES([CC])], + [m4_define([AC_PROG_CC], + m4_defn([AC_PROG_CC])[_AM_DEPENDENCIES([CC])])])dnl +AC_PROVIDE_IFELSE([AC_PROG_CXX], + [_AM_DEPENDENCIES([CXX])], + [m4_define([AC_PROG_CXX], + m4_defn([AC_PROG_CXX])[_AM_DEPENDENCIES([CXX])])])dnl +AC_PROVIDE_IFELSE([AC_PROG_OBJC], + [_AM_DEPENDENCIES([OBJC])], + [m4_define([AC_PROG_OBJC], + m4_defn([AC_PROG_OBJC])[_AM_DEPENDENCIES([OBJC])])])dnl +AC_PROVIDE_IFELSE([AC_PROG_OBJCXX], + [_AM_DEPENDENCIES([OBJCXX])], + [m4_define([AC_PROG_OBJCXX], + m4_defn([AC_PROG_OBJCXX])[_AM_DEPENDENCIES([OBJCXX])])])dnl +]) +AC_REQUIRE([AM_SILENT_RULES])dnl +dnl The testsuite driver may need to know about EXEEXT, so add the +dnl 'am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen. This +dnl macro is hooked onto _AC_COMPILER_EXEEXT early, see below. +AC_CONFIG_COMMANDS_PRE(dnl +[m4_provide_if([_AM_COMPILER_EXEEXT], + [AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])])])dnl + +# POSIX will say in a future version that running "rm -f" with no argument +# is OK; and we want to be able to make that assumption in our Makefile +# recipes. So use an aggressive probe to check that the usage we want is +# actually supported "in the wild" to an acceptable degree. +# See automake bug#10828. +# To make any issue more visible, cause the running configure to be aborted +# by default if the 'rm' program in use doesn't match our expectations; the +# user can still override this though. +if rm -f && rm -fr && rm -rf; then : OK; else + cat >&2 <<'END' +Oops! + +Your 'rm' program seems unable to run without file operands specified +on the command line, even when the '-f' option is present. This is contrary +to the behaviour of most rm programs out there, and not conforming with +the upcoming POSIX standard: + +Please tell bug-automake@gnu.org about your system, including the value +of your $PATH and any error possibly output before this message. This +can help us improve future automake versions. + +END + if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then + echo 'Configuration will proceed anyway, since you have set the' >&2 + echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2 + echo >&2 + else + cat >&2 <<'END' +Aborting the configuration process, to ensure you take notice of the issue. + +You can download and install GNU coreutils to get an 'rm' implementation +that behaves properly: . + +If you want to complete the configuration process using your problematic +'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM +to "yes", and re-run configure. + +END + AC_MSG_ERROR([Your 'rm' program is bad, sorry.]) + fi +fi]) + +dnl Hook into '_AC_COMPILER_EXEEXT' early to learn its expansion. Do not +dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further +dnl mangled by Autoconf and run in a shell conditional statement. +m4_define([_AC_COMPILER_EXEEXT], +m4_defn([_AC_COMPILER_EXEEXT])[m4_provide([_AM_COMPILER_EXEEXT])]) + +# When config.status generates a header, we must update the stamp-h file. +# This file resides in the same directory as the config header +# that is generated. The stamp files are numbered to have different names. + +# Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the +# loop where config.status creates the headers, so we can generate +# our stamp files there. +AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK], +[# Compute $1's index in $config_headers. +_am_arg=$1 +_am_stamp_count=1 +for _am_header in $config_headers :; do + case $_am_header in + $_am_arg | $_am_arg:* ) + break ;; + * ) + _am_stamp_count=`expr $_am_stamp_count + 1` ;; + esac +done +echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count]) + +# Copyright (C) 2001-2013 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_PROG_INSTALL_SH +# ------------------ +# Define $install_sh. +AC_DEFUN([AM_PROG_INSTALL_SH], +[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl +if test x"${install_sh}" != xset; then + case $am_aux_dir in + *\ * | *\ *) + install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;; + *) + install_sh="\${SHELL} $am_aux_dir/install-sh" + esac +fi +AC_SUBST([install_sh])]) + +# Copyright (C) 2003-2013 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# Check whether the underlying file-system supports filenames +# with a leading dot. For instance MS-DOS doesn't. +AC_DEFUN([AM_SET_LEADING_DOT], +[rm -rf .tst 2>/dev/null +mkdir .tst 2>/dev/null +if test -d .tst; then + am__leading_dot=. +else + am__leading_dot=_ +fi +rmdir .tst 2>/dev/null +AC_SUBST([am__leading_dot])]) + +# Check to see how 'make' treats includes. -*- Autoconf -*- + +# Copyright (C) 2001-2013 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_MAKE_INCLUDE() +# ----------------- +# Check to see how make treats includes. +AC_DEFUN([AM_MAKE_INCLUDE], +[am_make=${MAKE-make} +cat > confinc << 'END' +am__doit: + @echo this is the am__doit target +.PHONY: am__doit +END +# If we don't find an include directive, just comment out the code. +AC_MSG_CHECKING([for style of include used by $am_make]) +am__include="#" +am__quote= +_am_result=none +# First try GNU make style include. +echo "include confinc" > confmf +# Ignore all kinds of additional output from 'make'. +case `$am_make -s -f confmf 2> /dev/null` in #( +*the\ am__doit\ target*) + am__include=include + am__quote= + _am_result=GNU + ;; +esac +# Now try BSD make style include. +if test "$am__include" = "#"; then + echo '.include "confinc"' > confmf + case `$am_make -s -f confmf 2> /dev/null` in #( + *the\ am__doit\ target*) + am__include=.include + am__quote="\"" + _am_result=BSD + ;; + esac +fi +AC_SUBST([am__include]) +AC_SUBST([am__quote]) +AC_MSG_RESULT([$_am_result]) +rm -f confinc confmf +]) + +# Fake the existence of programs that GNU maintainers use. -*- Autoconf -*- + +# Copyright (C) 1997-2013 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_MISSING_PROG(NAME, PROGRAM) +# ------------------------------ +AC_DEFUN([AM_MISSING_PROG], +[AC_REQUIRE([AM_MISSING_HAS_RUN]) +$1=${$1-"${am_missing_run}$2"} +AC_SUBST($1)]) + +# AM_MISSING_HAS_RUN +# ------------------ +# Define MISSING if not defined so far and test if it is modern enough. +# If it is, set am_missing_run to use it, otherwise, to nothing. +AC_DEFUN([AM_MISSING_HAS_RUN], +[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl +AC_REQUIRE_AUX_FILE([missing])dnl +if test x"${MISSING+set}" != xset; then + case $am_aux_dir in + *\ * | *\ *) + MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;; + *) + MISSING="\${SHELL} $am_aux_dir/missing" ;; + esac +fi +# Use eval to expand $SHELL +if eval "$MISSING --is-lightweight"; then + am_missing_run="$MISSING " +else + am_missing_run= + AC_MSG_WARN(['missing' script is too old or missing]) +fi +]) + +# Helper functions for option handling. -*- Autoconf -*- + +# Copyright (C) 2001-2013 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# _AM_MANGLE_OPTION(NAME) +# ----------------------- +AC_DEFUN([_AM_MANGLE_OPTION], +[[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])]) + +# _AM_SET_OPTION(NAME) +# -------------------- +# Set option NAME. Presently that only means defining a flag for this option. +AC_DEFUN([_AM_SET_OPTION], +[m4_define(_AM_MANGLE_OPTION([$1]), [1])]) + +# _AM_SET_OPTIONS(OPTIONS) +# ------------------------ +# OPTIONS is a space-separated list of Automake options. +AC_DEFUN([_AM_SET_OPTIONS], +[m4_foreach_w([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])]) + +# _AM_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET]) +# ------------------------------------------- +# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise. +AC_DEFUN([_AM_IF_OPTION], +[m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])]) + +# Copyright (C) 1999-2013 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# _AM_PROG_CC_C_O +# --------------- +# Like AC_PROG_CC_C_O, but changed for automake. We rewrite AC_PROG_CC +# to automatically call this. +AC_DEFUN([_AM_PROG_CC_C_O], +[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl +AC_REQUIRE_AUX_FILE([compile])dnl +AC_LANG_PUSH([C])dnl +AC_CACHE_CHECK( + [whether $CC understands -c and -o together], + [am_cv_prog_cc_c_o], + [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])]) + # Make sure it works both with $CC and with simple cc. + # Following AC_PROG_CC_C_O, we do the test twice because some + # compilers refuse to overwrite an existing .o file with -o, + # though they will create one. + am_cv_prog_cc_c_o=yes + for am_i in 1 2; do + if AM_RUN_LOG([$CC -c conftest.$ac_ext -o conftest2.$ac_objext]) \ + && test -f conftest2.$ac_objext; then + : OK + else + am_cv_prog_cc_c_o=no + break + fi + done + rm -f core conftest* + unset am_i]) +if test "$am_cv_prog_cc_c_o" != yes; then + # Losing compiler, so override with the script. + # FIXME: It is wrong to rewrite CC. + # But if we don't then we get into trouble of one sort or another. + # A longer-term fix would be to have automake use am__CC in this case, + # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)" + CC="$am_aux_dir/compile $CC" +fi +AC_LANG_POP([C])]) + +# For backward compatibility. +AC_DEFUN_ONCE([AM_PROG_CC_C_O], [AC_REQUIRE([AC_PROG_CC])]) + +# Copyright (C) 1999-2013 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + + +# AM_PATH_PYTHON([MINIMUM-VERSION], [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +# --------------------------------------------------------------------------- +# Adds support for distributing Python modules and packages. To +# install modules, copy them to $(pythondir), using the python_PYTHON +# automake variable. To install a package with the same name as the +# automake package, install to $(pkgpythondir), or use the +# pkgpython_PYTHON automake variable. +# +# The variables $(pyexecdir) and $(pkgpyexecdir) are provided as +# locations to install python extension modules (shared libraries). +# Another macro is required to find the appropriate flags to compile +# extension modules. +# +# If your package is configured with a different prefix to python, +# users will have to add the install directory to the PYTHONPATH +# environment variable, or create a .pth file (see the python +# documentation for details). +# +# If the MINIMUM-VERSION argument is passed, AM_PATH_PYTHON will +# cause an error if the version of python installed on the system +# doesn't meet the requirement. MINIMUM-VERSION should consist of +# numbers and dots only. +AC_DEFUN([AM_PATH_PYTHON], + [ + dnl Find a Python interpreter. Python versions prior to 2.0 are not + dnl supported. (2.0 was released on October 16, 2000). + m4_define_default([_AM_PYTHON_INTERPRETER_LIST], +[python python2 python3 python3.3 python3.2 python3.1 python3.0 python2.7 dnl + python2.6 python2.5 python2.4 python2.3 python2.2 python2.1 python2.0]) + + AC_ARG_VAR([PYTHON], [the Python interpreter]) + + m4_if([$1],[],[ + dnl No version check is needed. + # Find any Python interpreter. + if test -z "$PYTHON"; then + AC_PATH_PROGS([PYTHON], _AM_PYTHON_INTERPRETER_LIST, :) + fi + am_display_PYTHON=python + ], [ + dnl A version check is needed. + if test -n "$PYTHON"; then + # If the user set $PYTHON, use it and don't search something else. + AC_MSG_CHECKING([whether $PYTHON version is >= $1]) + AM_PYTHON_CHECK_VERSION([$PYTHON], [$1], + [AC_MSG_RESULT([yes])], + [AC_MSG_RESULT([no]) + AC_MSG_ERROR([Python interpreter is too old])]) + am_display_PYTHON=$PYTHON + else + # Otherwise, try each interpreter until we find one that satisfies + # VERSION. + AC_CACHE_CHECK([for a Python interpreter with version >= $1], + [am_cv_pathless_PYTHON],[ + for am_cv_pathless_PYTHON in _AM_PYTHON_INTERPRETER_LIST none; do + test "$am_cv_pathless_PYTHON" = none && break + AM_PYTHON_CHECK_VERSION([$am_cv_pathless_PYTHON], [$1], [break]) + done]) + # Set $PYTHON to the absolute path of $am_cv_pathless_PYTHON. + if test "$am_cv_pathless_PYTHON" = none; then + PYTHON=: + else + AC_PATH_PROG([PYTHON], [$am_cv_pathless_PYTHON]) + fi + am_display_PYTHON=$am_cv_pathless_PYTHON + fi + ]) + + if test "$PYTHON" = :; then + dnl Run any user-specified action, or abort. + m4_default([$3], [AC_MSG_ERROR([no suitable Python interpreter found])]) + else + + dnl Query Python for its version number. Getting [:3] seems to be + dnl the best way to do this; it's what "site.py" does in the standard + dnl library. + + AC_CACHE_CHECK([for $am_display_PYTHON version], [am_cv_python_version], + [am_cv_python_version=`$PYTHON -c "import sys; sys.stdout.write(sys.version[[:3]])"`]) + AC_SUBST([PYTHON_VERSION], [$am_cv_python_version]) + + dnl Use the values of $prefix and $exec_prefix for the corresponding + dnl values of PYTHON_PREFIX and PYTHON_EXEC_PREFIX. These are made + dnl distinct variables so they can be overridden if need be. However, + dnl general consensus is that you shouldn't need this ability. + + AC_SUBST([PYTHON_PREFIX], ['${prefix}']) + AC_SUBST([PYTHON_EXEC_PREFIX], ['${exec_prefix}']) + + dnl At times (like when building shared libraries) you may want + dnl to know which OS platform Python thinks this is. + + AC_CACHE_CHECK([for $am_display_PYTHON platform], [am_cv_python_platform], + [am_cv_python_platform=`$PYTHON -c "import sys; sys.stdout.write(sys.platform)"`]) + AC_SUBST([PYTHON_PLATFORM], [$am_cv_python_platform]) + + # Just factor out some code duplication. + am_python_setup_sysconfig="\ +import sys +# Prefer sysconfig over distutils.sysconfig, for better compatibility +# with python 3.x. See automake bug#10227. +try: + import sysconfig +except ImportError: + can_use_sysconfig = 0 +else: + can_use_sysconfig = 1 +# Can't use sysconfig in CPython 2.7, since it's broken in virtualenvs: +# +try: + from platform import python_implementation + if python_implementation() == 'CPython' and sys.version[[:3]] == '2.7': + can_use_sysconfig = 0 +except ImportError: + pass" + + dnl Set up 4 directories: + + dnl pythondir -- where to install python scripts. This is the + dnl site-packages directory, not the python standard library + dnl directory like in previous automake betas. This behavior + dnl is more consistent with lispdir.m4 for example. + dnl Query distutils for this directory. + AC_CACHE_CHECK([for $am_display_PYTHON script directory], + [am_cv_python_pythondir], + [if test "x$prefix" = xNONE + then + am_py_prefix=$ac_default_prefix + else + am_py_prefix=$prefix + fi + am_cv_python_pythondir=`$PYTHON -c " +$am_python_setup_sysconfig +if can_use_sysconfig: + sitedir = sysconfig.get_path('purelib', vars={'base':'$am_py_prefix'}) +else: + from distutils import sysconfig + sitedir = sysconfig.get_python_lib(0, 0, prefix='$am_py_prefix') +sys.stdout.write(sitedir)"` + case $am_cv_python_pythondir in + $am_py_prefix*) + am__strip_prefix=`echo "$am_py_prefix" | sed 's|.|.|g'` + am_cv_python_pythondir=`echo "$am_cv_python_pythondir" | sed "s,^$am__strip_prefix,$PYTHON_PREFIX,"` + ;; + *) + case $am_py_prefix in + /usr|/System*) ;; + *) + am_cv_python_pythondir=$PYTHON_PREFIX/lib/python$PYTHON_VERSION/site-packages + ;; + esac + ;; + esac + ]) + AC_SUBST([pythondir], [$am_cv_python_pythondir]) + + dnl pkgpythondir -- $PACKAGE directory under pythondir. Was + dnl PYTHON_SITE_PACKAGE in previous betas, but this naming is + dnl more consistent with the rest of automake. + + AC_SUBST([pkgpythondir], [\${pythondir}/$PACKAGE]) + + dnl pyexecdir -- directory for installing python extension modules + dnl (shared libraries) + dnl Query distutils for this directory. + AC_CACHE_CHECK([for $am_display_PYTHON extension module directory], + [am_cv_python_pyexecdir], + [if test "x$exec_prefix" = xNONE + then + am_py_exec_prefix=$am_py_prefix + else + am_py_exec_prefix=$exec_prefix + fi + am_cv_python_pyexecdir=`$PYTHON -c " +$am_python_setup_sysconfig +if can_use_sysconfig: + sitedir = sysconfig.get_path('platlib', vars={'platbase':'$am_py_prefix'}) +else: + from distutils import sysconfig + sitedir = sysconfig.get_python_lib(1, 0, prefix='$am_py_prefix') +sys.stdout.write(sitedir)"` + case $am_cv_python_pyexecdir in + $am_py_exec_prefix*) + am__strip_prefix=`echo "$am_py_exec_prefix" | sed 's|.|.|g'` + am_cv_python_pyexecdir=`echo "$am_cv_python_pyexecdir" | sed "s,^$am__strip_prefix,$PYTHON_EXEC_PREFIX,"` + ;; + *) + case $am_py_exec_prefix in + /usr|/System*) ;; + *) + am_cv_python_pyexecdir=$PYTHON_EXEC_PREFIX/lib/python$PYTHON_VERSION/site-packages + ;; + esac + ;; + esac + ]) + AC_SUBST([pyexecdir], [$am_cv_python_pyexecdir]) + + dnl pkgpyexecdir -- $(pyexecdir)/$(PACKAGE) + + AC_SUBST([pkgpyexecdir], [\${pyexecdir}/$PACKAGE]) + + dnl Run any user-specified action. + $2 + fi + +]) + + +# AM_PYTHON_CHECK_VERSION(PROG, VERSION, [ACTION-IF-TRUE], [ACTION-IF-FALSE]) +# --------------------------------------------------------------------------- +# Run ACTION-IF-TRUE if the Python interpreter PROG has version >= VERSION. +# Run ACTION-IF-FALSE otherwise. +# This test uses sys.hexversion instead of the string equivalent (first +# word of sys.version), in order to cope with versions such as 2.2c1. +# This supports Python 2.0 or higher. (2.0 was released on October 16, 2000). +AC_DEFUN([AM_PYTHON_CHECK_VERSION], + [prog="import sys +# split strings by '.' and convert to numeric. Append some zeros +# because we need at least 4 digits for the hex conversion. +# map returns an iterator in Python 3.0 and a list in 2.x +minver = list(map(int, '$2'.split('.'))) + [[0, 0, 0]] +minverhex = 0 +# xrange is not present in Python 3.0 and range returns an iterator +for i in list(range(0, 4)): minverhex = (minverhex << 8) + minver[[i]] +sys.exit(sys.hexversion < minverhex)" + AS_IF([AM_RUN_LOG([$1 -c "$prog"])], [$3], [$4])]) + +# Copyright (C) 2001-2013 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_RUN_LOG(COMMAND) +# ------------------- +# Run COMMAND, save the exit status in ac_status, and log it. +# (This has been adapted from Autoconf's _AC_RUN_LOG macro.) +AC_DEFUN([AM_RUN_LOG], +[{ echo "$as_me:$LINENO: $1" >&AS_MESSAGE_LOG_FD + ($1) >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD + (exit $ac_status); }]) + +# Check to make sure that the build environment is sane. -*- Autoconf -*- + +# Copyright (C) 1996-2013 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_SANITY_CHECK +# --------------- +AC_DEFUN([AM_SANITY_CHECK], +[AC_MSG_CHECKING([whether build environment is sane]) +# Reject unsafe characters in $srcdir or the absolute working directory +# name. Accept space and tab only in the latter. +am_lf=' +' +case `pwd` in + *[[\\\"\#\$\&\'\`$am_lf]]*) + AC_MSG_ERROR([unsafe absolute working directory name]);; +esac +case $srcdir in + *[[\\\"\#\$\&\'\`$am_lf\ \ ]]*) + AC_MSG_ERROR([unsafe srcdir value: '$srcdir']);; +esac + +# Do 'set' in a subshell so we don't clobber the current shell's +# arguments. Must try -L first in case configure is actually a +# symlink; some systems play weird games with the mod time of symlinks +# (eg FreeBSD returns the mod time of the symlink's containing +# directory). +if ( + am_has_slept=no + for am_try in 1 2; do + echo "timestamp, slept: $am_has_slept" > conftest.file + set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null` + if test "$[*]" = "X"; then + # -L didn't work. + set X `ls -t "$srcdir/configure" conftest.file` + fi + if test "$[*]" != "X $srcdir/configure conftest.file" \ + && test "$[*]" != "X conftest.file $srcdir/configure"; then + + # If neither matched, then we have a broken ls. This can happen + # if, for instance, CONFIG_SHELL is bash and it inherits a + # broken ls alias from the environment. This has actually + # happened. Such a system could not be considered "sane". + AC_MSG_ERROR([ls -t appears to fail. Make sure there is not a broken + alias in your environment]) + fi + if test "$[2]" = conftest.file || test $am_try -eq 2; then + break + fi + # Just in case. + sleep 1 + am_has_slept=yes + done + test "$[2]" = conftest.file + ) +then + # Ok. + : +else + AC_MSG_ERROR([newly created file is older than distributed files! +Check your system clock]) +fi +AC_MSG_RESULT([yes]) +# If we didn't sleep, we still need to ensure time stamps of config.status and +# generated files are strictly newer. +am_sleep_pid= +if grep 'slept: no' conftest.file >/dev/null 2>&1; then + ( sleep 1 ) & + am_sleep_pid=$! +fi +AC_CONFIG_COMMANDS_PRE( + [AC_MSG_CHECKING([that generated files are newer than configure]) + if test -n "$am_sleep_pid"; then + # Hide warnings about reused PIDs. + wait $am_sleep_pid 2>/dev/null + fi + AC_MSG_RESULT([done])]) +rm -f conftest.file +]) + +# Copyright (C) 2009-2013 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_SILENT_RULES([DEFAULT]) +# -------------------------- +# Enable less verbose build rules; with the default set to DEFAULT +# ("yes" being less verbose, "no" or empty being verbose). +AC_DEFUN([AM_SILENT_RULES], +[AC_ARG_ENABLE([silent-rules], [dnl +AS_HELP_STRING( + [--enable-silent-rules], + [less verbose build output (undo: "make V=1")]) +AS_HELP_STRING( + [--disable-silent-rules], + [verbose build output (undo: "make V=0")])dnl +]) +case $enable_silent_rules in @%:@ ((( + yes) AM_DEFAULT_VERBOSITY=0;; + no) AM_DEFAULT_VERBOSITY=1;; + *) AM_DEFAULT_VERBOSITY=m4_if([$1], [yes], [0], [1]);; +esac +dnl +dnl A few 'make' implementations (e.g., NonStop OS and NextStep) +dnl do not support nested variable expansions. +dnl See automake bug#9928 and bug#10237. +am_make=${MAKE-make} +AC_CACHE_CHECK([whether $am_make supports nested variables], + [am_cv_make_support_nested_variables], + [if AS_ECHO([['TRUE=$(BAR$(V)) +BAR0=false +BAR1=true +V=1 +am__doit: + @$(TRUE) +.PHONY: am__doit']]) | $am_make -f - >/dev/null 2>&1; then + am_cv_make_support_nested_variables=yes +else + am_cv_make_support_nested_variables=no +fi]) +if test $am_cv_make_support_nested_variables = yes; then + dnl Using '$V' instead of '$(V)' breaks IRIX make. + AM_V='$(V)' + AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)' +else + AM_V=$AM_DEFAULT_VERBOSITY + AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY +fi +AC_SUBST([AM_V])dnl +AM_SUBST_NOTMAKE([AM_V])dnl +AC_SUBST([AM_DEFAULT_V])dnl +AM_SUBST_NOTMAKE([AM_DEFAULT_V])dnl +AC_SUBST([AM_DEFAULT_VERBOSITY])dnl +AM_BACKSLASH='\' +AC_SUBST([AM_BACKSLASH])dnl +_AM_SUBST_NOTMAKE([AM_BACKSLASH])dnl +]) + +# Copyright (C) 2001-2013 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_PROG_INSTALL_STRIP +# --------------------- +# One issue with vendor 'install' (even GNU) is that you can't +# specify the program used to strip binaries. This is especially +# annoying in cross-compiling environments, where the build's strip +# is unlikely to handle the host's binaries. +# Fortunately install-sh will honor a STRIPPROG variable, so we +# always use install-sh in "make install-strip", and initialize +# STRIPPROG with the value of the STRIP variable (set by the user). +AC_DEFUN([AM_PROG_INSTALL_STRIP], +[AC_REQUIRE([AM_PROG_INSTALL_SH])dnl +# Installed binaries are usually stripped using 'strip' when the user +# run "make install-strip". However 'strip' might not be the right +# tool to use in cross-compilation environments, therefore Automake +# will honor the 'STRIP' environment variable to overrule this program. +dnl Don't test for $cross_compiling = yes, because it might be 'maybe'. +if test "$cross_compiling" != no; then + AC_CHECK_TOOL([STRIP], [strip], :) +fi +INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s" +AC_SUBST([INSTALL_STRIP_PROGRAM])]) + +# Copyright (C) 2006-2013 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# _AM_SUBST_NOTMAKE(VARIABLE) +# --------------------------- +# Prevent Automake from outputting VARIABLE = @VARIABLE@ in Makefile.in. +# This macro is traced by Automake. +AC_DEFUN([_AM_SUBST_NOTMAKE]) + +# AM_SUBST_NOTMAKE(VARIABLE) +# -------------------------- +# Public sister of _AM_SUBST_NOTMAKE. +AC_DEFUN([AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE($@)]) + +# Check how to create a tarball. -*- Autoconf -*- + +# Copyright (C) 2004-2013 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# _AM_PROG_TAR(FORMAT) +# -------------------- +# Check how to create a tarball in format FORMAT. +# FORMAT should be one of 'v7', 'ustar', or 'pax'. +# +# Substitute a variable $(am__tar) that is a command +# writing to stdout a FORMAT-tarball containing the directory +# $tardir. +# tardir=directory && $(am__tar) > result.tar +# +# Substitute a variable $(am__untar) that extract such +# a tarball read from stdin. +# $(am__untar) < result.tar +# +AC_DEFUN([_AM_PROG_TAR], +[# Always define AMTAR for backward compatibility. Yes, it's still used +# in the wild :-( We should find a proper way to deprecate it ... +AC_SUBST([AMTAR], ['$${TAR-tar}']) + +# We'll loop over all known methods to create a tar archive until one works. +_am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none' + +m4_if([$1], [v7], + [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'], + + [m4_case([$1], + [ustar], + [# The POSIX 1988 'ustar' format is defined with fixed-size fields. + # There is notably a 21 bits limit for the UID and the GID. In fact, + # the 'pax' utility can hang on bigger UID/GID (see automake bug#8343 + # and bug#13588). + am_max_uid=2097151 # 2^21 - 1 + am_max_gid=$am_max_uid + # The $UID and $GID variables are not portable, so we need to resort + # to the POSIX-mandated id(1) utility. Errors in the 'id' calls + # below are definitely unexpected, so allow the users to see them + # (that is, avoid stderr redirection). + am_uid=`id -u || echo unknown` + am_gid=`id -g || echo unknown` + AC_MSG_CHECKING([whether UID '$am_uid' is supported by ustar format]) + if test $am_uid -le $am_max_uid; then + AC_MSG_RESULT([yes]) + else + AC_MSG_RESULT([no]) + _am_tools=none + fi + AC_MSG_CHECKING([whether GID '$am_gid' is supported by ustar format]) + if test $am_gid -le $am_max_gid; then + AC_MSG_RESULT([yes]) + else + AC_MSG_RESULT([no]) + _am_tools=none + fi], + + [pax], + [], + + [m4_fatal([Unknown tar format])]) + + AC_MSG_CHECKING([how to create a $1 tar archive]) + + # Go ahead even if we have the value already cached. We do so because we + # need to set the values for the 'am__tar' and 'am__untar' variables. + _am_tools=${am_cv_prog_tar_$1-$_am_tools} + + for _am_tool in $_am_tools; do + case $_am_tool in + gnutar) + for _am_tar in tar gnutar gtar; do + AM_RUN_LOG([$_am_tar --version]) && break + done + am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"' + am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"' + am__untar="$_am_tar -xf -" + ;; + plaintar) + # Must skip GNU tar: if it does not support --format= it doesn't create + # ustar tarball either. + (tar --version) >/dev/null 2>&1 && continue + am__tar='tar chf - "$$tardir"' + am__tar_='tar chf - "$tardir"' + am__untar='tar xf -' + ;; + pax) + am__tar='pax -L -x $1 -w "$$tardir"' + am__tar_='pax -L -x $1 -w "$tardir"' + am__untar='pax -r' + ;; + cpio) + am__tar='find "$$tardir" -print | cpio -o -H $1 -L' + am__tar_='find "$tardir" -print | cpio -o -H $1 -L' + am__untar='cpio -i -H $1 -d' + ;; + none) + am__tar=false + am__tar_=false + am__untar=false + ;; + esac + + # If the value was cached, stop now. We just wanted to have am__tar + # and am__untar set. + test -n "${am_cv_prog_tar_$1}" && break + + # tar/untar a dummy directory, and stop if the command works. + rm -rf conftest.dir + mkdir conftest.dir + echo GrepMe > conftest.dir/file + AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar]) + rm -rf conftest.dir + if test -s conftest.tar; then + AM_RUN_LOG([$am__untar /dev/null 2>&1 && break + fi + done + rm -rf conftest.dir + + AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool]) + AC_MSG_RESULT([$am_cv_prog_tar_$1])]) + +AC_SUBST([am__tar]) +AC_SUBST([am__untar]) +]) # _AM_PROG_TAR + +m4_include([m4/ac_python_devel.m4]) +m4_include([m4/libtool.m4]) +m4_include([m4/ltoptions.m4]) +m4_include([m4/ltsugar.m4]) +m4_include([m4/ltversion.m4]) +m4_include([m4/lt~obsolete.m4]) diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/ar-lib b/native_client/ctcdecode/third_party/openfst-1.6.7/ar-lib new file mode 100755 index 0000000000..fe2301e71a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/ar-lib @@ -0,0 +1,270 @@ +#! /bin/sh +# Wrapper for Microsoft lib.exe + +me=ar-lib +scriptversion=2012-03-01.08; # UTC + +# Copyright (C) 2010-2013 Free Software Foundation, Inc. +# Written by Peter Rosin . +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, or (at your option) +# any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +# This file is maintained in Automake, please report +# bugs to or send patches to +# . + + +# func_error message +func_error () +{ + echo "$me: $1" 1>&2 + exit 1 +} + +file_conv= + +# func_file_conv build_file +# Convert a $build file to $host form and store it in $file +# Currently only supports Windows hosts. +func_file_conv () +{ + file=$1 + case $file in + / | /[!/]*) # absolute file, and not a UNC file + if test -z "$file_conv"; then + # lazily determine how to convert abs files + case `uname -s` in + MINGW*) + file_conv=mingw + ;; + CYGWIN*) + file_conv=cygwin + ;; + *) + file_conv=wine + ;; + esac + fi + case $file_conv in + mingw) + file=`cmd //C echo "$file " | sed -e 's/"\(.*\) " *$/\1/'` + ;; + cygwin) + file=`cygpath -m "$file" || echo "$file"` + ;; + wine) + file=`winepath -w "$file" || echo "$file"` + ;; + esac + ;; + esac +} + +# func_at_file at_file operation archive +# Iterate over all members in AT_FILE performing OPERATION on ARCHIVE +# for each of them. +# When interpreting the content of the @FILE, do NOT use func_file_conv, +# since the user would need to supply preconverted file names to +# binutils ar, at least for MinGW. +func_at_file () +{ + operation=$2 + archive=$3 + at_file_contents=`cat "$1"` + eval set x "$at_file_contents" + shift + + for member + do + $AR -NOLOGO $operation:"$member" "$archive" || exit $? + done +} + +case $1 in + '') + func_error "no command. Try '$0 --help' for more information." + ;; + -h | --h*) + cat <. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, or (at your option) +# any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +# This file is maintained in Automake, please report +# bugs to or send patches to +# . + +nl=' +' + +# We need space, tab and new line, in precisely that order. Quoting is +# there to prevent tools from complaining about whitespace usage. +IFS=" "" $nl" + +file_conv= + +# func_file_conv build_file lazy +# Convert a $build file to $host form and store it in $file +# Currently only supports Windows hosts. If the determined conversion +# type is listed in (the comma separated) LAZY, no conversion will +# take place. +func_file_conv () +{ + file=$1 + case $file in + / | /[!/]*) # absolute file, and not a UNC file + if test -z "$file_conv"; then + # lazily determine how to convert abs files + case `uname -s` in + MINGW*) + file_conv=mingw + ;; + CYGWIN*) + file_conv=cygwin + ;; + *) + file_conv=wine + ;; + esac + fi + case $file_conv/,$2, in + *,$file_conv,*) + ;; + mingw/*) + file=`cmd //C echo "$file " | sed -e 's/"\(.*\) " *$/\1/'` + ;; + cygwin/*) + file=`cygpath -m "$file" || echo "$file"` + ;; + wine/*) + file=`winepath -w "$file" || echo "$file"` + ;; + esac + ;; + esac +} + +# func_cl_dashL linkdir +# Make cl look for libraries in LINKDIR +func_cl_dashL () +{ + func_file_conv "$1" + if test -z "$lib_path"; then + lib_path=$file + else + lib_path="$lib_path;$file" + fi + linker_opts="$linker_opts -LIBPATH:$file" +} + +# func_cl_dashl library +# Do a library search-path lookup for cl +func_cl_dashl () +{ + lib=$1 + found=no + save_IFS=$IFS + IFS=';' + for dir in $lib_path $LIB + do + IFS=$save_IFS + if $shared && test -f "$dir/$lib.dll.lib"; then + found=yes + lib=$dir/$lib.dll.lib + break + fi + if test -f "$dir/$lib.lib"; then + found=yes + lib=$dir/$lib.lib + break + fi + if test -f "$dir/lib$lib.a"; then + found=yes + lib=$dir/lib$lib.a + break + fi + done + IFS=$save_IFS + + if test "$found" != yes; then + lib=$lib.lib + fi +} + +# func_cl_wrapper cl arg... +# Adjust compile command to suit cl +func_cl_wrapper () +{ + # Assume a capable shell + lib_path= + shared=: + linker_opts= + for arg + do + if test -n "$eat"; then + eat= + else + case $1 in + -o) + # configure might choose to run compile as 'compile cc -o foo foo.c'. + eat=1 + case $2 in + *.o | *.[oO][bB][jJ]) + func_file_conv "$2" + set x "$@" -Fo"$file" + shift + ;; + *) + func_file_conv "$2" + set x "$@" -Fe"$file" + shift + ;; + esac + ;; + -I) + eat=1 + func_file_conv "$2" mingw + set x "$@" -I"$file" + shift + ;; + -I*) + func_file_conv "${1#-I}" mingw + set x "$@" -I"$file" + shift + ;; + -l) + eat=1 + func_cl_dashl "$2" + set x "$@" "$lib" + shift + ;; + -l*) + func_cl_dashl "${1#-l}" + set x "$@" "$lib" + shift + ;; + -L) + eat=1 + func_cl_dashL "$2" + ;; + -L*) + func_cl_dashL "${1#-L}" + ;; + -static) + shared=false + ;; + -Wl,*) + arg=${1#-Wl,} + save_ifs="$IFS"; IFS=',' + for flag in $arg; do + IFS="$save_ifs" + linker_opts="$linker_opts $flag" + done + IFS="$save_ifs" + ;; + -Xlinker) + eat=1 + linker_opts="$linker_opts $2" + ;; + -*) + set x "$@" "$1" + shift + ;; + *.cc | *.CC | *.cxx | *.CXX | *.[cC]++) + func_file_conv "$1" + set x "$@" -Tp"$file" + shift + ;; + *.c | *.cpp | *.CPP | *.lib | *.LIB | *.Lib | *.OBJ | *.obj | *.[oO]) + func_file_conv "$1" mingw + set x "$@" "$file" + shift + ;; + *) + set x "$@" "$1" + shift + ;; + esac + fi + shift + done + if test -n "$linker_opts"; then + linker_opts="-link$linker_opts" + fi + exec "$@" $linker_opts + exit 1 +} + +eat= + +case $1 in + '') + echo "$0: No command. Try '$0 --help' for more information." 1>&2 + exit 1; + ;; + -h | --h*) + cat <<\EOF +Usage: compile [--help] [--version] PROGRAM [ARGS] + +Wrapper for compilers which do not understand '-c -o'. +Remove '-o dest.o' from ARGS, run PROGRAM with the remaining +arguments, and rename the output as expected. + +If you are trying to build a whole package this is not the +right script to run: please start by reading the file 'INSTALL'. + +Report bugs to . +EOF + exit $? + ;; + -v | --v*) + echo "compile $scriptversion" + exit $? + ;; + cl | *[/\\]cl | cl.exe | *[/\\]cl.exe ) + func_cl_wrapper "$@" # Doesn't return... + ;; +esac + +ofile= +cfile= + +for arg +do + if test -n "$eat"; then + eat= + else + case $1 in + -o) + # configure might choose to run compile as 'compile cc -o foo foo.c'. + # So we strip '-o arg' only if arg is an object. + eat=1 + case $2 in + *.o | *.obj) + ofile=$2 + ;; + *) + set x "$@" -o "$2" + shift + ;; + esac + ;; + *.c) + cfile=$1 + set x "$@" "$1" + shift + ;; + *) + set x "$@" "$1" + shift + ;; + esac + fi + shift +done + +if test -z "$ofile" || test -z "$cfile"; then + # If no '-o' option was seen then we might have been invoked from a + # pattern rule where we don't need one. That is ok -- this is a + # normal compilation that the losing compiler can handle. If no + # '.c' file was seen then we are probably linking. That is also + # ok. + exec "$@" +fi + +# Name of file we expect compiler to create. +cofile=`echo "$cfile" | sed 's|^.*[\\/]||; s|^[a-zA-Z]:||; s/\.c$/.o/'` + +# Create the lock directory. +# Note: use '[/\\:.-]' here to ensure that we don't use the same name +# that we are using for the .o file. Also, base the name on the expected +# object file name, since that is what matters with a parallel build. +lockdir=`echo "$cofile" | sed -e 's|[/\\:.-]|_|g'`.d +while true; do + if mkdir "$lockdir" >/dev/null 2>&1; then + break + fi + sleep 1 +done +# FIXME: race condition here if user kills between mkdir and trap. +trap "rmdir '$lockdir'; exit 1" 1 2 15 + +# Run the compile. +"$@" +ret=$? + +if test -f "$cofile"; then + test "$cofile" = "$ofile" || mv "$cofile" "$ofile" +elif test -f "${cofile}bj"; then + test "${cofile}bj" = "$ofile" || mv "${cofile}bj" "$ofile" +fi + +rmdir "$lockdir" +exit $ret + +# Local Variables: +# mode: shell-script +# sh-indentation: 2 +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "scriptversion=" +# time-stamp-format: "%:y-%02m-%02d.%02H" +# time-stamp-time-zone: "UTC" +# time-stamp-end: "; # UTC" +# End: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/config.guess b/native_client/ctcdecode/third_party/openfst-1.6.7/config.guess new file mode 100755 index 0000000000..b79252d6b1 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/config.guess @@ -0,0 +1,1558 @@ +#! /bin/sh +# Attempt to guess a canonical system name. +# Copyright 1992-2013 Free Software Foundation, Inc. + +timestamp='2013-06-10' + +# This file is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, see . +# +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that +# program. This Exception is an additional permission under section 7 +# of the GNU General Public License, version 3 ("GPLv3"). +# +# Originally written by Per Bothner. +# +# You can get the latest version of this script from: +# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD +# +# Please send patches with a ChangeLog entry to config-patches@gnu.org. + + +me=`echo "$0" | sed -e 's,.*/,,'` + +usage="\ +Usage: $0 [OPTION] + +Output the configuration name of the system \`$me' is run on. + +Operation modes: + -h, --help print this help, then exit + -t, --time-stamp print date of last modification, then exit + -v, --version print version number, then exit + +Report bugs and patches to ." + +version="\ +GNU config.guess ($timestamp) + +Originally written by Per Bothner. +Copyright 1992-2013 Free Software Foundation, Inc. + +This is free software; see the source for copying conditions. There is NO +warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." + +help=" +Try \`$me --help' for more information." + +# Parse command line +while test $# -gt 0 ; do + case $1 in + --time-stamp | --time* | -t ) + echo "$timestamp" ; exit ;; + --version | -v ) + echo "$version" ; exit ;; + --help | --h* | -h ) + echo "$usage"; exit ;; + -- ) # Stop option processing + shift; break ;; + - ) # Use stdin as input. + break ;; + -* ) + echo "$me: invalid option $1$help" >&2 + exit 1 ;; + * ) + break ;; + esac +done + +if test $# != 0; then + echo "$me: too many arguments$help" >&2 + exit 1 +fi + +trap 'exit 1' 1 2 15 + +# CC_FOR_BUILD -- compiler used by this script. Note that the use of a +# compiler to aid in system detection is discouraged as it requires +# temporary files to be created and, as you can see below, it is a +# headache to deal with in a portable fashion. + +# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still +# use `HOST_CC' if defined, but it is deprecated. + +# Portable tmp directory creation inspired by the Autoconf team. + +set_cc_for_build=' +trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ; +trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ; +: ${TMPDIR=/tmp} ; + { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || + { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } || + { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } || + { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ; +dummy=$tmp/dummy ; +tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ; +case $CC_FOR_BUILD,$HOST_CC,$CC in + ,,) echo "int x;" > $dummy.c ; + for c in cc gcc c89 c99 ; do + if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then + CC_FOR_BUILD="$c"; break ; + fi ; + done ; + if test x"$CC_FOR_BUILD" = x ; then + CC_FOR_BUILD=no_compiler_found ; + fi + ;; + ,,*) CC_FOR_BUILD=$CC ;; + ,*,*) CC_FOR_BUILD=$HOST_CC ;; +esac ; set_cc_for_build= ;' + +# This is needed to find uname on a Pyramid OSx when run in the BSD universe. +# (ghazi@noc.rutgers.edu 1994-08-24) +if (test -f /.attbin/uname) >/dev/null 2>&1 ; then + PATH=$PATH:/.attbin ; export PATH +fi + +UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown +UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown +UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown +UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown + +case "${UNAME_SYSTEM}" in +Linux|GNU|GNU/*) + # If the system lacks a compiler, then just pick glibc. + # We could probably try harder. + LIBC=gnu + + eval $set_cc_for_build + cat <<-EOF > $dummy.c + #include + #if defined(__UCLIBC__) + LIBC=uclibc + #elif defined(__dietlibc__) + LIBC=dietlibc + #else + LIBC=gnu + #endif + EOF + eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC'` + ;; +esac + +# Note: order is significant - the case branches are not exclusive. + +case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in + *:NetBSD:*:*) + # NetBSD (nbsd) targets should (where applicable) match one or + # more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*, + # *-*-netbsdecoff* and *-*-netbsd*. For targets that recently + # switched to ELF, *-*-netbsd* would select the old + # object file format. This provides both forward + # compatibility and a consistent mechanism for selecting the + # object file format. + # + # Note: NetBSD doesn't particularly care about the vendor + # portion of the name. We always set it to "unknown". + sysctl="sysctl -n hw.machine_arch" + UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \ + /usr/sbin/$sysctl 2>/dev/null || echo unknown)` + case "${UNAME_MACHINE_ARCH}" in + armeb) machine=armeb-unknown ;; + arm*) machine=arm-unknown ;; + sh3el) machine=shl-unknown ;; + sh3eb) machine=sh-unknown ;; + sh5el) machine=sh5le-unknown ;; + *) machine=${UNAME_MACHINE_ARCH}-unknown ;; + esac + # The Operating System including object format, if it has switched + # to ELF recently, or will in the future. + case "${UNAME_MACHINE_ARCH}" in + arm*|i386|m68k|ns32k|sh3*|sparc|vax) + eval $set_cc_for_build + if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \ + | grep -q __ELF__ + then + # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout). + # Return netbsd for either. FIX? + os=netbsd + else + os=netbsdelf + fi + ;; + *) + os=netbsd + ;; + esac + # The OS release + # Debian GNU/NetBSD machines have a different userland, and + # thus, need a distinct triplet. However, they do not need + # kernel version information, so it can be replaced with a + # suitable tag, in the style of linux-gnu. + case "${UNAME_VERSION}" in + Debian*) + release='-gnu' + ;; + *) + release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'` + ;; + esac + # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: + # contains redundant information, the shorter form: + # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. + echo "${machine}-${os}${release}" + exit ;; + *:Bitrig:*:*) + UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'` + echo ${UNAME_MACHINE_ARCH}-unknown-bitrig${UNAME_RELEASE} + exit ;; + *:OpenBSD:*:*) + UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'` + echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE} + exit ;; + *:ekkoBSD:*:*) + echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE} + exit ;; + *:SolidBSD:*:*) + echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE} + exit ;; + macppc:MirBSD:*:*) + echo powerpc-unknown-mirbsd${UNAME_RELEASE} + exit ;; + *:MirBSD:*:*) + echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE} + exit ;; + alpha:OSF1:*:*) + case $UNAME_RELEASE in + *4.0) + UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` + ;; + *5.*) + UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'` + ;; + esac + # According to Compaq, /usr/sbin/psrinfo has been available on + # OSF/1 and Tru64 systems produced since 1995. I hope that + # covers most systems running today. This code pipes the CPU + # types through head -n 1, so we only detect the type of CPU 0. + ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1` + case "$ALPHA_CPU_TYPE" in + "EV4 (21064)") + UNAME_MACHINE="alpha" ;; + "EV4.5 (21064)") + UNAME_MACHINE="alpha" ;; + "LCA4 (21066/21068)") + UNAME_MACHINE="alpha" ;; + "EV5 (21164)") + UNAME_MACHINE="alphaev5" ;; + "EV5.6 (21164A)") + UNAME_MACHINE="alphaev56" ;; + "EV5.6 (21164PC)") + UNAME_MACHINE="alphapca56" ;; + "EV5.7 (21164PC)") + UNAME_MACHINE="alphapca57" ;; + "EV6 (21264)") + UNAME_MACHINE="alphaev6" ;; + "EV6.7 (21264A)") + UNAME_MACHINE="alphaev67" ;; + "EV6.8CB (21264C)") + UNAME_MACHINE="alphaev68" ;; + "EV6.8AL (21264B)") + UNAME_MACHINE="alphaev68" ;; + "EV6.8CX (21264D)") + UNAME_MACHINE="alphaev68" ;; + "EV6.9A (21264/EV69A)") + UNAME_MACHINE="alphaev69" ;; + "EV7 (21364)") + UNAME_MACHINE="alphaev7" ;; + "EV7.9 (21364A)") + UNAME_MACHINE="alphaev79" ;; + esac + # A Pn.n version is a patched version. + # A Vn.n version is a released version. + # A Tn.n version is a released field test version. + # A Xn.n version is an unreleased experimental baselevel. + # 1.2 uses "1.2" for uname -r. + echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + # Reset EXIT trap before exiting to avoid spurious non-zero exit code. + exitcode=$? + trap '' 0 + exit $exitcode ;; + Alpha\ *:Windows_NT*:*) + # How do we know it's Interix rather than the generic POSIX subsystem? + # Should we change UNAME_MACHINE based on the output of uname instead + # of the specific Alpha model? + echo alpha-pc-interix + exit ;; + 21064:Windows_NT:50:3) + echo alpha-dec-winnt3.5 + exit ;; + Amiga*:UNIX_System_V:4.0:*) + echo m68k-unknown-sysv4 + exit ;; + *:[Aa]miga[Oo][Ss]:*:*) + echo ${UNAME_MACHINE}-unknown-amigaos + exit ;; + *:[Mm]orph[Oo][Ss]:*:*) + echo ${UNAME_MACHINE}-unknown-morphos + exit ;; + *:OS/390:*:*) + echo i370-ibm-openedition + exit ;; + *:z/VM:*:*) + echo s390-ibm-zvmoe + exit ;; + *:OS400:*:*) + echo powerpc-ibm-os400 + exit ;; + arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) + echo arm-acorn-riscix${UNAME_RELEASE} + exit ;; + arm*:riscos:*:*|arm*:RISCOS:*:*) + echo arm-unknown-riscos + exit ;; + SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) + echo hppa1.1-hitachi-hiuxmpp + exit ;; + Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*) + # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. + if test "`(/bin/universe) 2>/dev/null`" = att ; then + echo pyramid-pyramid-sysv3 + else + echo pyramid-pyramid-bsd + fi + exit ;; + NILE*:*:*:dcosx) + echo pyramid-pyramid-svr4 + exit ;; + DRS?6000:unix:4.0:6*) + echo sparc-icl-nx6 + exit ;; + DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*) + case `/usr/bin/uname -p` in + sparc) echo sparc-icl-nx7; exit ;; + esac ;; + s390x:SunOS:*:*) + echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + sun4H:SunOS:5.*:*) + echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) + echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*) + echo i386-pc-auroraux${UNAME_RELEASE} + exit ;; + i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*) + eval $set_cc_for_build + SUN_ARCH="i386" + # If there is a compiler, see if it is configured for 64-bit objects. + # Note that the Sun cc does not turn __LP64__ into 1 like gcc does. + # This test works for both compilers. + if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then + if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \ + (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \ + grep IS_64BIT_ARCH >/dev/null + then + SUN_ARCH="x86_64" + fi + fi + echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + sun4*:SunOS:6*:*) + # According to config.sub, this is the proper way to canonicalize + # SunOS6. Hard to guess exactly what SunOS6 will be like, but + # it's likely to be more like Solaris than SunOS4. + echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + sun4*:SunOS:*:*) + case "`/usr/bin/arch -k`" in + Series*|S4*) + UNAME_RELEASE=`uname -v` + ;; + esac + # Japanese Language versions have a version number like `4.1.3-JL'. + echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'` + exit ;; + sun3*:SunOS:*:*) + echo m68k-sun-sunos${UNAME_RELEASE} + exit ;; + sun*:*:4.2BSD:*) + UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` + test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3 + case "`/bin/arch`" in + sun3) + echo m68k-sun-sunos${UNAME_RELEASE} + ;; + sun4) + echo sparc-sun-sunos${UNAME_RELEASE} + ;; + esac + exit ;; + aushp:SunOS:*:*) + echo sparc-auspex-sunos${UNAME_RELEASE} + exit ;; + # The situation for MiNT is a little confusing. The machine name + # can be virtually everything (everything which is not + # "atarist" or "atariste" at least should have a processor + # > m68000). The system name ranges from "MiNT" over "FreeMiNT" + # to the lowercase version "mint" (or "freemint"). Finally + # the system name "TOS" denotes a system which is actually not + # MiNT. But MiNT is downward compatible to TOS, so this should + # be no problem. + atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit ;; + atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit ;; + *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit ;; + milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) + echo m68k-milan-mint${UNAME_RELEASE} + exit ;; + hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) + echo m68k-hades-mint${UNAME_RELEASE} + exit ;; + *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) + echo m68k-unknown-mint${UNAME_RELEASE} + exit ;; + m68k:machten:*:*) + echo m68k-apple-machten${UNAME_RELEASE} + exit ;; + powerpc:machten:*:*) + echo powerpc-apple-machten${UNAME_RELEASE} + exit ;; + RISC*:Mach:*:*) + echo mips-dec-mach_bsd4.3 + exit ;; + RISC*:ULTRIX:*:*) + echo mips-dec-ultrix${UNAME_RELEASE} + exit ;; + VAX*:ULTRIX*:*:*) + echo vax-dec-ultrix${UNAME_RELEASE} + exit ;; + 2020:CLIX:*:* | 2430:CLIX:*:*) + echo clipper-intergraph-clix${UNAME_RELEASE} + exit ;; + mips:*:*:UMIPS | mips:*:*:RISCos) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c +#ifdef __cplusplus +#include /* for printf() prototype */ + int main (int argc, char *argv[]) { +#else + int main (argc, argv) int argc; char *argv[]; { +#endif + #if defined (host_mips) && defined (MIPSEB) + #if defined (SYSTYPE_SYSV) + printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0); + #endif + #if defined (SYSTYPE_SVR4) + printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0); + #endif + #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD) + printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0); + #endif + #endif + exit (-1); + } +EOF + $CC_FOR_BUILD -o $dummy $dummy.c && + dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` && + SYSTEM_NAME=`$dummy $dummyarg` && + { echo "$SYSTEM_NAME"; exit; } + echo mips-mips-riscos${UNAME_RELEASE} + exit ;; + Motorola:PowerMAX_OS:*:*) + echo powerpc-motorola-powermax + exit ;; + Motorola:*:4.3:PL8-*) + echo powerpc-harris-powermax + exit ;; + Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) + echo powerpc-harris-powermax + exit ;; + Night_Hawk:Power_UNIX:*:*) + echo powerpc-harris-powerunix + exit ;; + m88k:CX/UX:7*:*) + echo m88k-harris-cxux7 + exit ;; + m88k:*:4*:R4*) + echo m88k-motorola-sysv4 + exit ;; + m88k:*:3*:R3*) + echo m88k-motorola-sysv3 + exit ;; + AViiON:dgux:*:*) + # DG/UX returns AViiON for all architectures + UNAME_PROCESSOR=`/usr/bin/uname -p` + if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ] + then + if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \ + [ ${TARGET_BINARY_INTERFACE}x = x ] + then + echo m88k-dg-dgux${UNAME_RELEASE} + else + echo m88k-dg-dguxbcs${UNAME_RELEASE} + fi + else + echo i586-dg-dgux${UNAME_RELEASE} + fi + exit ;; + M88*:DolphinOS:*:*) # DolphinOS (SVR3) + echo m88k-dolphin-sysv3 + exit ;; + M88*:*:R3*:*) + # Delta 88k system running SVR3 + echo m88k-motorola-sysv3 + exit ;; + XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) + echo m88k-tektronix-sysv3 + exit ;; + Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) + echo m68k-tektronix-bsd + exit ;; + *:IRIX*:*:*) + echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'` + exit ;; + ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. + echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id + exit ;; # Note that: echo "'`uname -s`'" gives 'AIX ' + i*86:AIX:*:*) + echo i386-ibm-aix + exit ;; + ia64:AIX:*:*) + if [ -x /usr/bin/oslevel ] ; then + IBM_REV=`/usr/bin/oslevel` + else + IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} + fi + echo ${UNAME_MACHINE}-ibm-aix${IBM_REV} + exit ;; + *:AIX:2:3) + if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + + main() + { + if (!__power_pc()) + exit(1); + puts("powerpc-ibm-aix3.2.5"); + exit(0); + } +EOF + if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` + then + echo "$SYSTEM_NAME" + else + echo rs6000-ibm-aix3.2.5 + fi + elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then + echo rs6000-ibm-aix3.2.4 + else + echo rs6000-ibm-aix3.2 + fi + exit ;; + *:AIX:*:[4567]) + IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` + if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then + IBM_ARCH=rs6000 + else + IBM_ARCH=powerpc + fi + if [ -x /usr/bin/oslevel ] ; then + IBM_REV=`/usr/bin/oslevel` + else + IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} + fi + echo ${IBM_ARCH}-ibm-aix${IBM_REV} + exit ;; + *:AIX:*:*) + echo rs6000-ibm-aix + exit ;; + ibmrt:4.4BSD:*|romp-ibm:BSD:*) + echo romp-ibm-bsd4.4 + exit ;; + ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and + echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to + exit ;; # report: romp-ibm BSD 4.3 + *:BOSX:*:*) + echo rs6000-bull-bosx + exit ;; + DPX/2?00:B.O.S.:*:*) + echo m68k-bull-sysv3 + exit ;; + 9000/[34]??:4.3bsd:1.*:*) + echo m68k-hp-bsd + exit ;; + hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) + echo m68k-hp-bsd4.4 + exit ;; + 9000/[34678]??:HP-UX:*:*) + HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` + case "${UNAME_MACHINE}" in + 9000/31? ) HP_ARCH=m68000 ;; + 9000/[34]?? ) HP_ARCH=m68k ;; + 9000/[678][0-9][0-9]) + if [ -x /usr/bin/getconf ]; then + sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` + sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` + case "${sc_cpu_version}" in + 523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0 + 528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1 + 532) # CPU_PA_RISC2_0 + case "${sc_kernel_bits}" in + 32) HP_ARCH="hppa2.0n" ;; + 64) HP_ARCH="hppa2.0w" ;; + '') HP_ARCH="hppa2.0" ;; # HP-UX 10.20 + esac ;; + esac + fi + if [ "${HP_ARCH}" = "" ]; then + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + + #define _HPUX_SOURCE + #include + #include + + int main () + { + #if defined(_SC_KERNEL_BITS) + long bits = sysconf(_SC_KERNEL_BITS); + #endif + long cpu = sysconf (_SC_CPU_VERSION); + + switch (cpu) + { + case CPU_PA_RISC1_0: puts ("hppa1.0"); break; + case CPU_PA_RISC1_1: puts ("hppa1.1"); break; + case CPU_PA_RISC2_0: + #if defined(_SC_KERNEL_BITS) + switch (bits) + { + case 64: puts ("hppa2.0w"); break; + case 32: puts ("hppa2.0n"); break; + default: puts ("hppa2.0"); break; + } break; + #else /* !defined(_SC_KERNEL_BITS) */ + puts ("hppa2.0"); break; + #endif + default: puts ("hppa1.0"); break; + } + exit (0); + } +EOF + (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy` + test -z "$HP_ARCH" && HP_ARCH=hppa + fi ;; + esac + if [ ${HP_ARCH} = "hppa2.0w" ] + then + eval $set_cc_for_build + + # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating + # 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler + # generating 64-bit code. GNU and HP use different nomenclature: + # + # $ CC_FOR_BUILD=cc ./config.guess + # => hppa2.0w-hp-hpux11.23 + # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess + # => hppa64-hp-hpux11.23 + + if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | + grep -q __LP64__ + then + HP_ARCH="hppa2.0w" + else + HP_ARCH="hppa64" + fi + fi + echo ${HP_ARCH}-hp-hpux${HPUX_REV} + exit ;; + ia64:HP-UX:*:*) + HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` + echo ia64-hp-hpux${HPUX_REV} + exit ;; + 3050*:HI-UX:*:*) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + int + main () + { + long cpu = sysconf (_SC_CPU_VERSION); + /* The order matters, because CPU_IS_HP_MC68K erroneously returns + true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct + results, however. */ + if (CPU_IS_PA_RISC (cpu)) + { + switch (cpu) + { + case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break; + case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break; + case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break; + default: puts ("hppa-hitachi-hiuxwe2"); break; + } + } + else if (CPU_IS_HP_MC68K (cpu)) + puts ("m68k-hitachi-hiuxwe2"); + else puts ("unknown-hitachi-hiuxwe2"); + exit (0); + } +EOF + $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` && + { echo "$SYSTEM_NAME"; exit; } + echo unknown-hitachi-hiuxwe2 + exit ;; + 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* ) + echo hppa1.1-hp-bsd + exit ;; + 9000/8??:4.3bsd:*:*) + echo hppa1.0-hp-bsd + exit ;; + *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) + echo hppa1.0-hp-mpeix + exit ;; + hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* ) + echo hppa1.1-hp-osf + exit ;; + hp8??:OSF1:*:*) + echo hppa1.0-hp-osf + exit ;; + i*86:OSF1:*:*) + if [ -x /usr/sbin/sysversion ] ; then + echo ${UNAME_MACHINE}-unknown-osf1mk + else + echo ${UNAME_MACHINE}-unknown-osf1 + fi + exit ;; + parisc*:Lites*:*:*) + echo hppa1.1-hp-lites + exit ;; + C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) + echo c1-convex-bsd + exit ;; + C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) + if getsysinfo -f scalar_acc + then echo c32-convex-bsd + else echo c2-convex-bsd + fi + exit ;; + C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) + echo c34-convex-bsd + exit ;; + C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) + echo c38-convex-bsd + exit ;; + C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) + echo c4-convex-bsd + exit ;; + CRAY*Y-MP:*:*:*) + echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + CRAY*[A-Z]90:*:*:*) + echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \ + | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ + -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \ + -e 's/\.[^.]*$/.X/' + exit ;; + CRAY*TS:*:*:*) + echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + CRAY*T3E:*:*:*) + echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + CRAY*SV1:*:*:*) + echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + *:UNICOS/mp:*:*) + echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) + FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` + FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'` + echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" + exit ;; + 5000:UNIX_System_V:4.*:*) + FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` + FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'` + echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" + exit ;; + i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) + echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE} + exit ;; + sparc*:BSD/OS:*:*) + echo sparc-unknown-bsdi${UNAME_RELEASE} + exit ;; + *:BSD/OS:*:*) + echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE} + exit ;; + *:FreeBSD:*:*) + UNAME_PROCESSOR=`/usr/bin/uname -p` + case ${UNAME_PROCESSOR} in + amd64) + echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; + *) + echo ${UNAME_PROCESSOR}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; + esac + exit ;; + i*:CYGWIN*:*) + echo ${UNAME_MACHINE}-pc-cygwin + exit ;; + *:MINGW64*:*) + echo ${UNAME_MACHINE}-pc-mingw64 + exit ;; + *:MINGW*:*) + echo ${UNAME_MACHINE}-pc-mingw32 + exit ;; + i*:MSYS*:*) + echo ${UNAME_MACHINE}-pc-msys + exit ;; + i*:windows32*:*) + # uname -m includes "-pc" on this system. + echo ${UNAME_MACHINE}-mingw32 + exit ;; + i*:PW*:*) + echo ${UNAME_MACHINE}-pc-pw32 + exit ;; + *:Interix*:*) + case ${UNAME_MACHINE} in + x86) + echo i586-pc-interix${UNAME_RELEASE} + exit ;; + authenticamd | genuineintel | EM64T) + echo x86_64-unknown-interix${UNAME_RELEASE} + exit ;; + IA64) + echo ia64-unknown-interix${UNAME_RELEASE} + exit ;; + esac ;; + [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*) + echo i${UNAME_MACHINE}-pc-mks + exit ;; + 8664:Windows_NT:*) + echo x86_64-pc-mks + exit ;; + i*:Windows_NT*:* | Pentium*:Windows_NT*:*) + # How do we know it's Interix rather than the generic POSIX subsystem? + # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we + # UNAME_MACHINE based on the output of uname instead of i386? + echo i586-pc-interix + exit ;; + i*:UWIN*:*) + echo ${UNAME_MACHINE}-pc-uwin + exit ;; + amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*) + echo x86_64-unknown-cygwin + exit ;; + p*:CYGWIN*:*) + echo powerpcle-unknown-cygwin + exit ;; + prep*:SunOS:5.*:*) + echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + *:GNU:*:*) + # the GNU system + echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-${LIBC}`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'` + exit ;; + *:GNU/*:*:*) + # other systems with GNU libc and userland + echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-${LIBC} + exit ;; + i*86:Minix:*:*) + echo ${UNAME_MACHINE}-pc-minix + exit ;; + aarch64:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + aarch64_be:Linux:*:*) + UNAME_MACHINE=aarch64_be + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + alpha:Linux:*:*) + case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in + EV5) UNAME_MACHINE=alphaev5 ;; + EV56) UNAME_MACHINE=alphaev56 ;; + PCA56) UNAME_MACHINE=alphapca56 ;; + PCA57) UNAME_MACHINE=alphapca56 ;; + EV6) UNAME_MACHINE=alphaev6 ;; + EV67) UNAME_MACHINE=alphaev67 ;; + EV68*) UNAME_MACHINE=alphaev68 ;; + esac + objdump --private-headers /bin/sh | grep -q ld.so.1 + if test "$?" = 0 ; then LIBC="gnulibc1" ; fi + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + arc:Linux:*:* | arceb:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + arm*:Linux:*:*) + eval $set_cc_for_build + if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \ + | grep -q __ARM_EABI__ + then + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + else + if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \ + | grep -q __ARM_PCS_VFP + then + echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabi + else + echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabihf + fi + fi + exit ;; + avr32*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + cris:Linux:*:*) + echo ${UNAME_MACHINE}-axis-linux-${LIBC} + exit ;; + crisv32:Linux:*:*) + echo ${UNAME_MACHINE}-axis-linux-${LIBC} + exit ;; + frv:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + hexagon:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + i*86:Linux:*:*) + echo ${UNAME_MACHINE}-pc-linux-${LIBC} + exit ;; + ia64:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + m32r*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + m68*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + mips:Linux:*:* | mips64:Linux:*:*) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #undef CPU + #undef ${UNAME_MACHINE} + #undef ${UNAME_MACHINE}el + #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) + CPU=${UNAME_MACHINE}el + #else + #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) + CPU=${UNAME_MACHINE} + #else + CPU= + #endif + #endif +EOF + eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'` + test x"${CPU}" != x && { echo "${CPU}-unknown-linux-${LIBC}"; exit; } + ;; + or1k:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + or32:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + padre:Linux:*:*) + echo sparc-unknown-linux-${LIBC} + exit ;; + parisc64:Linux:*:* | hppa64:Linux:*:*) + echo hppa64-unknown-linux-${LIBC} + exit ;; + parisc:Linux:*:* | hppa:Linux:*:*) + # Look for CPU level + case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in + PA7*) echo hppa1.1-unknown-linux-${LIBC} ;; + PA8*) echo hppa2.0-unknown-linux-${LIBC} ;; + *) echo hppa-unknown-linux-${LIBC} ;; + esac + exit ;; + ppc64:Linux:*:*) + echo powerpc64-unknown-linux-${LIBC} + exit ;; + ppc:Linux:*:*) + echo powerpc-unknown-linux-${LIBC} + exit ;; + ppc64le:Linux:*:*) + echo powerpc64le-unknown-linux-${LIBC} + exit ;; + ppcle:Linux:*:*) + echo powerpcle-unknown-linux-${LIBC} + exit ;; + s390:Linux:*:* | s390x:Linux:*:*) + echo ${UNAME_MACHINE}-ibm-linux-${LIBC} + exit ;; + sh64*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + sh*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + sparc:Linux:*:* | sparc64:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + tile*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + vax:Linux:*:*) + echo ${UNAME_MACHINE}-dec-linux-${LIBC} + exit ;; + x86_64:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + xtensa*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + i*86:DYNIX/ptx:4*:*) + # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. + # earlier versions are messed up and put the nodename in both + # sysname and nodename. + echo i386-sequent-sysv4 + exit ;; + i*86:UNIX_SV:4.2MP:2.*) + # Unixware is an offshoot of SVR4, but it has its own version + # number series starting with 2... + # I am not positive that other SVR4 systems won't match this, + # I just have to hope. -- rms. + # Use sysv4.2uw... so that sysv4* matches it. + echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION} + exit ;; + i*86:OS/2:*:*) + # If we were able to find `uname', then EMX Unix compatibility + # is probably installed. + echo ${UNAME_MACHINE}-pc-os2-emx + exit ;; + i*86:XTS-300:*:STOP) + echo ${UNAME_MACHINE}-unknown-stop + exit ;; + i*86:atheos:*:*) + echo ${UNAME_MACHINE}-unknown-atheos + exit ;; + i*86:syllable:*:*) + echo ${UNAME_MACHINE}-pc-syllable + exit ;; + i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*) + echo i386-unknown-lynxos${UNAME_RELEASE} + exit ;; + i*86:*DOS:*:*) + echo ${UNAME_MACHINE}-pc-msdosdjgpp + exit ;; + i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*) + UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'` + if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then + echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL} + else + echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL} + fi + exit ;; + i*86:*:5:[678]*) + # UnixWare 7.x, OpenUNIX and OpenServer 6. + case `/bin/uname -X | grep "^Machine"` in + *486*) UNAME_MACHINE=i486 ;; + *Pentium) UNAME_MACHINE=i586 ;; + *Pent*|*Celeron) UNAME_MACHINE=i686 ;; + esac + echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION} + exit ;; + i*86:*:3.2:*) + if test -f /usr/options/cb.name; then + UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then + UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')` + (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486 + (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \ + && UNAME_MACHINE=i586 + (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \ + && UNAME_MACHINE=i686 + (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \ + && UNAME_MACHINE=i686 + echo ${UNAME_MACHINE}-pc-sco$UNAME_REL + else + echo ${UNAME_MACHINE}-pc-sysv32 + fi + exit ;; + pc:*:*:*) + # Left here for compatibility: + # uname -m prints for DJGPP always 'pc', but it prints nothing about + # the processor, so we play safe by assuming i586. + # Note: whatever this is, it MUST be the same as what config.sub + # prints for the "djgpp" host, or else GDB configury will decide that + # this is a cross-build. + echo i586-pc-msdosdjgpp + exit ;; + Intel:Mach:3*:*) + echo i386-pc-mach3 + exit ;; + paragon:*:*:*) + echo i860-intel-osf1 + exit ;; + i860:*:4.*:*) # i860-SVR4 + if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then + echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4 + else # Add other i860-SVR4 vendors below as they are discovered. + echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4 + fi + exit ;; + mini*:CTIX:SYS*5:*) + # "miniframe" + echo m68010-convergent-sysv + exit ;; + mc68k:UNIX:SYSTEM5:3.51m) + echo m68k-convergent-sysv + exit ;; + M680?0:D-NIX:5.3:*) + echo m68k-diab-dnix + exit ;; + M68*:*:R3V[5678]*:*) + test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;; + 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0) + OS_REL='' + test -r /etc/.relid \ + && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` + /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ + && { echo i486-ncr-sysv4.3${OS_REL}; exit; } + /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ + && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; + 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) + /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ + && { echo i486-ncr-sysv4; exit; } ;; + NCR*:*:4.2:* | MPRAS*:*:4.2:*) + OS_REL='.3' + test -r /etc/.relid \ + && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` + /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ + && { echo i486-ncr-sysv4.3${OS_REL}; exit; } + /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ + && { echo i586-ncr-sysv4.3${OS_REL}; exit; } + /bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \ + && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; + m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) + echo m68k-unknown-lynxos${UNAME_RELEASE} + exit ;; + mc68030:UNIX_System_V:4.*:*) + echo m68k-atari-sysv4 + exit ;; + TSUNAMI:LynxOS:2.*:*) + echo sparc-unknown-lynxos${UNAME_RELEASE} + exit ;; + rs6000:LynxOS:2.*:*) + echo rs6000-unknown-lynxos${UNAME_RELEASE} + exit ;; + PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*) + echo powerpc-unknown-lynxos${UNAME_RELEASE} + exit ;; + SM[BE]S:UNIX_SV:*:*) + echo mips-dde-sysv${UNAME_RELEASE} + exit ;; + RM*:ReliantUNIX-*:*:*) + echo mips-sni-sysv4 + exit ;; + RM*:SINIX-*:*:*) + echo mips-sni-sysv4 + exit ;; + *:SINIX-*:*:*) + if uname -p 2>/dev/null >/dev/null ; then + UNAME_MACHINE=`(uname -p) 2>/dev/null` + echo ${UNAME_MACHINE}-sni-sysv4 + else + echo ns32k-sni-sysv + fi + exit ;; + PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort + # says + echo i586-unisys-sysv4 + exit ;; + *:UNIX_System_V:4*:FTX*) + # From Gerald Hewes . + # How about differentiating between stratus architectures? -djm + echo hppa1.1-stratus-sysv4 + exit ;; + *:*:*:FTX*) + # From seanf@swdc.stratus.com. + echo i860-stratus-sysv4 + exit ;; + i*86:VOS:*:*) + # From Paul.Green@stratus.com. + echo ${UNAME_MACHINE}-stratus-vos + exit ;; + *:VOS:*:*) + # From Paul.Green@stratus.com. + echo hppa1.1-stratus-vos + exit ;; + mc68*:A/UX:*:*) + echo m68k-apple-aux${UNAME_RELEASE} + exit ;; + news*:NEWS-OS:6*:*) + echo mips-sony-newsos6 + exit ;; + R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) + if [ -d /usr/nec ]; then + echo mips-nec-sysv${UNAME_RELEASE} + else + echo mips-unknown-sysv${UNAME_RELEASE} + fi + exit ;; + BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. + echo powerpc-be-beos + exit ;; + BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. + echo powerpc-apple-beos + exit ;; + BePC:BeOS:*:*) # BeOS running on Intel PC compatible. + echo i586-pc-beos + exit ;; + BePC:Haiku:*:*) # Haiku running on Intel PC compatible. + echo i586-pc-haiku + exit ;; + x86_64:Haiku:*:*) + echo x86_64-unknown-haiku + exit ;; + SX-4:SUPER-UX:*:*) + echo sx4-nec-superux${UNAME_RELEASE} + exit ;; + SX-5:SUPER-UX:*:*) + echo sx5-nec-superux${UNAME_RELEASE} + exit ;; + SX-6:SUPER-UX:*:*) + echo sx6-nec-superux${UNAME_RELEASE} + exit ;; + SX-7:SUPER-UX:*:*) + echo sx7-nec-superux${UNAME_RELEASE} + exit ;; + SX-8:SUPER-UX:*:*) + echo sx8-nec-superux${UNAME_RELEASE} + exit ;; + SX-8R:SUPER-UX:*:*) + echo sx8r-nec-superux${UNAME_RELEASE} + exit ;; + Power*:Rhapsody:*:*) + echo powerpc-apple-rhapsody${UNAME_RELEASE} + exit ;; + *:Rhapsody:*:*) + echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE} + exit ;; + *:Darwin:*:*) + UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown + eval $set_cc_for_build + if test "$UNAME_PROCESSOR" = unknown ; then + UNAME_PROCESSOR=powerpc + fi + if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then + if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \ + (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \ + grep IS_64BIT_ARCH >/dev/null + then + case $UNAME_PROCESSOR in + i386) UNAME_PROCESSOR=x86_64 ;; + powerpc) UNAME_PROCESSOR=powerpc64 ;; + esac + fi + fi + echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE} + exit ;; + *:procnto*:*:* | *:QNX:[0123456789]*:*) + UNAME_PROCESSOR=`uname -p` + if test "$UNAME_PROCESSOR" = "x86"; then + UNAME_PROCESSOR=i386 + UNAME_MACHINE=pc + fi + echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE} + exit ;; + *:QNX:*:4*) + echo i386-pc-qnx + exit ;; + NEO-?:NONSTOP_KERNEL:*:*) + echo neo-tandem-nsk${UNAME_RELEASE} + exit ;; + NSE-*:NONSTOP_KERNEL:*:*) + echo nse-tandem-nsk${UNAME_RELEASE} + exit ;; + NSR-?:NONSTOP_KERNEL:*:*) + echo nsr-tandem-nsk${UNAME_RELEASE} + exit ;; + *:NonStop-UX:*:*) + echo mips-compaq-nonstopux + exit ;; + BS2000:POSIX*:*:*) + echo bs2000-siemens-sysv + exit ;; + DS/*:UNIX_System_V:*:*) + echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE} + exit ;; + *:Plan9:*:*) + # "uname -m" is not consistent, so use $cputype instead. 386 + # is converted to i386 for consistency with other x86 + # operating systems. + if test "$cputype" = "386"; then + UNAME_MACHINE=i386 + else + UNAME_MACHINE="$cputype" + fi + echo ${UNAME_MACHINE}-unknown-plan9 + exit ;; + *:TOPS-10:*:*) + echo pdp10-unknown-tops10 + exit ;; + *:TENEX:*:*) + echo pdp10-unknown-tenex + exit ;; + KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) + echo pdp10-dec-tops20 + exit ;; + XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) + echo pdp10-xkl-tops20 + exit ;; + *:TOPS-20:*:*) + echo pdp10-unknown-tops20 + exit ;; + *:ITS:*:*) + echo pdp10-unknown-its + exit ;; + SEI:*:*:SEIUX) + echo mips-sei-seiux${UNAME_RELEASE} + exit ;; + *:DragonFly:*:*) + echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` + exit ;; + *:*VMS:*:*) + UNAME_MACHINE=`(uname -p) 2>/dev/null` + case "${UNAME_MACHINE}" in + A*) echo alpha-dec-vms ; exit ;; + I*) echo ia64-dec-vms ; exit ;; + V*) echo vax-dec-vms ; exit ;; + esac ;; + *:XENIX:*:SysV) + echo i386-pc-xenix + exit ;; + i*86:skyos:*:*) + echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//' + exit ;; + i*86:rdos:*:*) + echo ${UNAME_MACHINE}-pc-rdos + exit ;; + i*86:AROS:*:*) + echo ${UNAME_MACHINE}-pc-aros + exit ;; + x86_64:VMkernel:*:*) + echo ${UNAME_MACHINE}-unknown-esx + exit ;; +esac + +eval $set_cc_for_build +cat >$dummy.c < +# include +#endif +main () +{ +#if defined (sony) +#if defined (MIPSEB) + /* BFD wants "bsd" instead of "newsos". Perhaps BFD should be changed, + I don't know.... */ + printf ("mips-sony-bsd\n"); exit (0); +#else +#include + printf ("m68k-sony-newsos%s\n", +#ifdef NEWSOS4 + "4" +#else + "" +#endif + ); exit (0); +#endif +#endif + +#if defined (__arm) && defined (__acorn) && defined (__unix) + printf ("arm-acorn-riscix\n"); exit (0); +#endif + +#if defined (hp300) && !defined (hpux) + printf ("m68k-hp-bsd\n"); exit (0); +#endif + +#if defined (NeXT) +#if !defined (__ARCHITECTURE__) +#define __ARCHITECTURE__ "m68k" +#endif + int version; + version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`; + if (version < 4) + printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version); + else + printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version); + exit (0); +#endif + +#if defined (MULTIMAX) || defined (n16) +#if defined (UMAXV) + printf ("ns32k-encore-sysv\n"); exit (0); +#else +#if defined (CMU) + printf ("ns32k-encore-mach\n"); exit (0); +#else + printf ("ns32k-encore-bsd\n"); exit (0); +#endif +#endif +#endif + +#if defined (__386BSD__) + printf ("i386-pc-bsd\n"); exit (0); +#endif + +#if defined (sequent) +#if defined (i386) + printf ("i386-sequent-dynix\n"); exit (0); +#endif +#if defined (ns32000) + printf ("ns32k-sequent-dynix\n"); exit (0); +#endif +#endif + +#if defined (_SEQUENT_) + struct utsname un; + + uname(&un); + + if (strncmp(un.version, "V2", 2) == 0) { + printf ("i386-sequent-ptx2\n"); exit (0); + } + if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */ + printf ("i386-sequent-ptx1\n"); exit (0); + } + printf ("i386-sequent-ptx\n"); exit (0); + +#endif + +#if defined (vax) +# if !defined (ultrix) +# include +# if defined (BSD) +# if BSD == 43 + printf ("vax-dec-bsd4.3\n"); exit (0); +# else +# if BSD == 199006 + printf ("vax-dec-bsd4.3reno\n"); exit (0); +# else + printf ("vax-dec-bsd\n"); exit (0); +# endif +# endif +# else + printf ("vax-dec-bsd\n"); exit (0); +# endif +# else + printf ("vax-dec-ultrix\n"); exit (0); +# endif +#endif + +#if defined (alliant) && defined (i860) + printf ("i860-alliant-bsd\n"); exit (0); +#endif + + exit (1); +} +EOF + +$CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && SYSTEM_NAME=`$dummy` && + { echo "$SYSTEM_NAME"; exit; } + +# Apollos put the system type in the environment. + +test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; } + +# Convex versions that predate uname can use getsysinfo(1) + +if [ -x /usr/convex/getsysinfo ] +then + case `getsysinfo -f cpu_type` in + c1*) + echo c1-convex-bsd + exit ;; + c2*) + if getsysinfo -f scalar_acc + then echo c32-convex-bsd + else echo c2-convex-bsd + fi + exit ;; + c34*) + echo c34-convex-bsd + exit ;; + c38*) + echo c38-convex-bsd + exit ;; + c4*) + echo c4-convex-bsd + exit ;; + esac +fi + +cat >&2 < in order to provide the needed +information to handle your system. + +config.guess timestamp = $timestamp + +uname -m = `(uname -m) 2>/dev/null || echo unknown` +uname -r = `(uname -r) 2>/dev/null || echo unknown` +uname -s = `(uname -s) 2>/dev/null || echo unknown` +uname -v = `(uname -v) 2>/dev/null || echo unknown` + +/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null` +/bin/uname -X = `(/bin/uname -X) 2>/dev/null` + +hostinfo = `(hostinfo) 2>/dev/null` +/bin/universe = `(/bin/universe) 2>/dev/null` +/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null` +/bin/arch = `(/bin/arch) 2>/dev/null` +/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null` +/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null` + +UNAME_MACHINE = ${UNAME_MACHINE} +UNAME_RELEASE = ${UNAME_RELEASE} +UNAME_SYSTEM = ${UNAME_SYSTEM} +UNAME_VERSION = ${UNAME_VERSION} +EOF + +exit 1 + +# Local variables: +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "timestamp='" +# time-stamp-format: "%:y-%02m-%02d" +# time-stamp-end: "'" +# End: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/config.h.in b/native_client/ctcdecode/third_party/openfst-1.6.7/config.h.in new file mode 100644 index 0000000000..423fcf8f0a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/config.h.in @@ -0,0 +1,62 @@ +/* config.h.in. Generated from configure.ac by autoheader. */ + +/* Define to 1 if you have the header file. */ +#undef HAVE_DLFCN_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_INTTYPES_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_MEMORY_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STDINT_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STDLIB_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STRINGS_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STRING_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_STAT_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_TYPES_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_UNISTD_H + +/* Define to the sub-directory in which libtool stores uninstalled libraries. + */ +#undef LT_OBJDIR + +/* Name of package */ +#undef PACKAGE + +/* Define to the address where bug reports for this package should be sent. */ +#undef PACKAGE_BUGREPORT + +/* Define to the full name of this package. */ +#undef PACKAGE_NAME + +/* Define to the full name and version of this package. */ +#undef PACKAGE_STRING + +/* Define to the one symbol short name of this package. */ +#undef PACKAGE_TARNAME + +/* Define to the home page for this package. */ +#undef PACKAGE_URL + +/* Define to the version of this package. */ +#undef PACKAGE_VERSION + +/* Define to 1 if you have the ANSI C header files. */ +#undef STDC_HEADERS + +/* Version number of package */ +#undef VERSION diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/config.sub b/native_client/ctcdecode/third_party/openfst-1.6.7/config.sub new file mode 100755 index 0000000000..9633db7046 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/config.sub @@ -0,0 +1,1791 @@ +#! /bin/sh +# Configuration validation subroutine script. +# Copyright 1992-2013 Free Software Foundation, Inc. + +timestamp='2013-08-10' + +# This file is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, see . +# +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that +# program. This Exception is an additional permission under section 7 +# of the GNU General Public License, version 3 ("GPLv3"). + + +# Please send patches with a ChangeLog entry to config-patches@gnu.org. +# +# Configuration subroutine to validate and canonicalize a configuration type. +# Supply the specified configuration type as an argument. +# If it is invalid, we print an error message on stderr and exit with code 1. +# Otherwise, we print the canonical config type on stdout and succeed. + +# You can get the latest version of this script from: +# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD + +# This file is supposed to be the same for all GNU packages +# and recognize all the CPU types, system types and aliases +# that are meaningful with *any* GNU software. +# Each package is responsible for reporting which valid configurations +# it does not support. The user should be able to distinguish +# a failure to support a valid configuration from a meaningless +# configuration. + +# The goal of this file is to map all the various variations of a given +# machine specification into a single specification in the form: +# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM +# or in some cases, the newer four-part form: +# CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM +# It is wrong to echo any other type of specification. + +me=`echo "$0" | sed -e 's,.*/,,'` + +usage="\ +Usage: $0 [OPTION] CPU-MFR-OPSYS + $0 [OPTION] ALIAS + +Canonicalize a configuration name. + +Operation modes: + -h, --help print this help, then exit + -t, --time-stamp print date of last modification, then exit + -v, --version print version number, then exit + +Report bugs and patches to ." + +version="\ +GNU config.sub ($timestamp) + +Copyright 1992-2013 Free Software Foundation, Inc. + +This is free software; see the source for copying conditions. There is NO +warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." + +help=" +Try \`$me --help' for more information." + +# Parse command line +while test $# -gt 0 ; do + case $1 in + --time-stamp | --time* | -t ) + echo "$timestamp" ; exit ;; + --version | -v ) + echo "$version" ; exit ;; + --help | --h* | -h ) + echo "$usage"; exit ;; + -- ) # Stop option processing + shift; break ;; + - ) # Use stdin as input. + break ;; + -* ) + echo "$me: invalid option $1$help" + exit 1 ;; + + *local*) + # First pass through any local machine types. + echo $1 + exit ;; + + * ) + break ;; + esac +done + +case $# in + 0) echo "$me: missing argument$help" >&2 + exit 1;; + 1) ;; + *) echo "$me: too many arguments$help" >&2 + exit 1;; +esac + +# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any). +# Here we must recognize all the valid KERNEL-OS combinations. +maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'` +case $maybe_os in + nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \ + linux-musl* | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \ + knetbsd*-gnu* | netbsd*-gnu* | \ + kopensolaris*-gnu* | \ + storm-chaos* | os2-emx* | rtmk-nova*) + os=-$maybe_os + basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'` + ;; + android-linux) + os=-linux-android + basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown + ;; + *) + basic_machine=`echo $1 | sed 's/-[^-]*$//'` + if [ $basic_machine != $1 ] + then os=`echo $1 | sed 's/.*-/-/'` + else os=; fi + ;; +esac + +### Let's recognize common machines as not being operating systems so +### that things like config.sub decstation-3100 work. We also +### recognize some manufacturers as not being operating systems, so we +### can provide default operating systems below. +case $os in + -sun*os*) + # Prevent following clause from handling this invalid input. + ;; + -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \ + -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \ + -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \ + -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\ + -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \ + -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \ + -apple | -axis | -knuth | -cray | -microblaze*) + os= + basic_machine=$1 + ;; + -bluegene*) + os=-cnk + ;; + -sim | -cisco | -oki | -wec | -winbond) + os= + basic_machine=$1 + ;; + -scout) + ;; + -wrs) + os=-vxworks + basic_machine=$1 + ;; + -chorusos*) + os=-chorusos + basic_machine=$1 + ;; + -chorusrdb) + os=-chorusrdb + basic_machine=$1 + ;; + -hiux*) + os=-hiuxwe2 + ;; + -sco6) + os=-sco5v6 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco5) + os=-sco3.2v5 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco4) + os=-sco3.2v4 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco3.2.[4-9]*) + os=`echo $os | sed -e 's/sco3.2./sco3.2v/'` + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco3.2v[4-9]*) + # Don't forget version if it is 3.2v4 or newer. + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco5v6*) + # Don't forget version if it is 3.2v4 or newer. + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco*) + os=-sco3.2v2 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -udk*) + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -isc) + os=-isc2.2 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -clix*) + basic_machine=clipper-intergraph + ;; + -isc*) + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -lynx*178) + os=-lynxos178 + ;; + -lynx*5) + os=-lynxos5 + ;; + -lynx*) + os=-lynxos + ;; + -ptx*) + basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'` + ;; + -windowsnt*) + os=`echo $os | sed -e 's/windowsnt/winnt/'` + ;; + -psos*) + os=-psos + ;; + -mint | -mint[0-9]*) + basic_machine=m68k-atari + os=-mint + ;; +esac + +# Decode aliases for certain CPU-COMPANY combinations. +case $basic_machine in + # Recognize the basic CPU types without company name. + # Some are omitted here because they have special meanings below. + 1750a | 580 \ + | a29k \ + | aarch64 | aarch64_be \ + | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \ + | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \ + | am33_2.0 \ + | arc | arceb \ + | arm | arm[bl]e | arme[lb] | armv[2-8] | armv[3-8][lb] | armv7[arm] \ + | avr | avr32 \ + | be32 | be64 \ + | bfin \ + | c4x | c8051 | clipper \ + | d10v | d30v | dlx | dsp16xx \ + | epiphany \ + | fido | fr30 | frv \ + | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \ + | hexagon \ + | i370 | i860 | i960 | ia64 \ + | ip2k | iq2000 \ + | le32 | le64 \ + | lm32 \ + | m32c | m32r | m32rle | m68000 | m68k | m88k \ + | maxq | mb | microblaze | microblazeel | mcore | mep | metag \ + | mips | mipsbe | mipseb | mipsel | mipsle \ + | mips16 \ + | mips64 | mips64el \ + | mips64octeon | mips64octeonel \ + | mips64orion | mips64orionel \ + | mips64r5900 | mips64r5900el \ + | mips64vr | mips64vrel \ + | mips64vr4100 | mips64vr4100el \ + | mips64vr4300 | mips64vr4300el \ + | mips64vr5000 | mips64vr5000el \ + | mips64vr5900 | mips64vr5900el \ + | mipsisa32 | mipsisa32el \ + | mipsisa32r2 | mipsisa32r2el \ + | mipsisa64 | mipsisa64el \ + | mipsisa64r2 | mipsisa64r2el \ + | mipsisa64sb1 | mipsisa64sb1el \ + | mipsisa64sr71k | mipsisa64sr71kel \ + | mipsr5900 | mipsr5900el \ + | mipstx39 | mipstx39el \ + | mn10200 | mn10300 \ + | moxie \ + | mt \ + | msp430 \ + | nds32 | nds32le | nds32be \ + | nios | nios2 | nios2eb | nios2el \ + | ns16k | ns32k \ + | open8 \ + | or1k | or32 \ + | pdp10 | pdp11 | pj | pjl \ + | powerpc | powerpc64 | powerpc64le | powerpcle \ + | pyramid \ + | rl78 | rx \ + | score \ + | sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \ + | sh64 | sh64le \ + | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \ + | sparcv8 | sparcv9 | sparcv9b | sparcv9v \ + | spu \ + | tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \ + | ubicom32 \ + | v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \ + | we32k \ + | x86 | xc16x | xstormy16 | xtensa \ + | z8k | z80) + basic_machine=$basic_machine-unknown + ;; + c54x) + basic_machine=tic54x-unknown + ;; + c55x) + basic_machine=tic55x-unknown + ;; + c6x) + basic_machine=tic6x-unknown + ;; + m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | picochip) + basic_machine=$basic_machine-unknown + os=-none + ;; + m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k) + ;; + ms1) + basic_machine=mt-unknown + ;; + + strongarm | thumb | xscale) + basic_machine=arm-unknown + ;; + xgate) + basic_machine=$basic_machine-unknown + os=-none + ;; + xscaleeb) + basic_machine=armeb-unknown + ;; + + xscaleel) + basic_machine=armel-unknown + ;; + + # We use `pc' rather than `unknown' + # because (1) that's what they normally are, and + # (2) the word "unknown" tends to confuse beginning users. + i*86 | x86_64) + basic_machine=$basic_machine-pc + ;; + # Object if more than one company name word. + *-*-*) + echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 + exit 1 + ;; + # Recognize the basic CPU types with company name. + 580-* \ + | a29k-* \ + | aarch64-* | aarch64_be-* \ + | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \ + | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \ + | alphapca5[67]-* | alpha64pca5[67]-* | arc-* | arceb-* \ + | arm-* | armbe-* | armle-* | armeb-* | armv*-* \ + | avr-* | avr32-* \ + | be32-* | be64-* \ + | bfin-* | bs2000-* \ + | c[123]* | c30-* | [cjt]90-* | c4x-* \ + | c8051-* | clipper-* | craynv-* | cydra-* \ + | d10v-* | d30v-* | dlx-* \ + | elxsi-* \ + | f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \ + | h8300-* | h8500-* \ + | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \ + | hexagon-* \ + | i*86-* | i860-* | i960-* | ia64-* \ + | ip2k-* | iq2000-* \ + | le32-* | le64-* \ + | lm32-* \ + | m32c-* | m32r-* | m32rle-* \ + | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \ + | m88110-* | m88k-* | maxq-* | mcore-* | metag-* \ + | microblaze-* | microblazeel-* \ + | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \ + | mips16-* \ + | mips64-* | mips64el-* \ + | mips64octeon-* | mips64octeonel-* \ + | mips64orion-* | mips64orionel-* \ + | mips64r5900-* | mips64r5900el-* \ + | mips64vr-* | mips64vrel-* \ + | mips64vr4100-* | mips64vr4100el-* \ + | mips64vr4300-* | mips64vr4300el-* \ + | mips64vr5000-* | mips64vr5000el-* \ + | mips64vr5900-* | mips64vr5900el-* \ + | mipsisa32-* | mipsisa32el-* \ + | mipsisa32r2-* | mipsisa32r2el-* \ + | mipsisa64-* | mipsisa64el-* \ + | mipsisa64r2-* | mipsisa64r2el-* \ + | mipsisa64sb1-* | mipsisa64sb1el-* \ + | mipsisa64sr71k-* | mipsisa64sr71kel-* \ + | mipsr5900-* | mipsr5900el-* \ + | mipstx39-* | mipstx39el-* \ + | mmix-* \ + | mt-* \ + | msp430-* \ + | nds32-* | nds32le-* | nds32be-* \ + | nios-* | nios2-* | nios2eb-* | nios2el-* \ + | none-* | np1-* | ns16k-* | ns32k-* \ + | open8-* \ + | orion-* \ + | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \ + | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \ + | pyramid-* \ + | rl78-* | romp-* | rs6000-* | rx-* \ + | sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \ + | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \ + | sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \ + | sparclite-* \ + | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx?-* \ + | tahoe-* \ + | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \ + | tile*-* \ + | tron-* \ + | ubicom32-* \ + | v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \ + | vax-* \ + | we32k-* \ + | x86-* | x86_64-* | xc16x-* | xps100-* \ + | xstormy16-* | xtensa*-* \ + | ymp-* \ + | z8k-* | z80-*) + ;; + # Recognize the basic CPU types without company name, with glob match. + xtensa*) + basic_machine=$basic_machine-unknown + ;; + # Recognize the various machine names and aliases which stand + # for a CPU type and a company and sometimes even an OS. + 386bsd) + basic_machine=i386-unknown + os=-bsd + ;; + 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc) + basic_machine=m68000-att + ;; + 3b*) + basic_machine=we32k-att + ;; + a29khif) + basic_machine=a29k-amd + os=-udi + ;; + abacus) + basic_machine=abacus-unknown + ;; + adobe68k) + basic_machine=m68010-adobe + os=-scout + ;; + alliant | fx80) + basic_machine=fx80-alliant + ;; + altos | altos3068) + basic_machine=m68k-altos + ;; + am29k) + basic_machine=a29k-none + os=-bsd + ;; + amd64) + basic_machine=x86_64-pc + ;; + amd64-*) + basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + amdahl) + basic_machine=580-amdahl + os=-sysv + ;; + amiga | amiga-*) + basic_machine=m68k-unknown + ;; + amigaos | amigados) + basic_machine=m68k-unknown + os=-amigaos + ;; + amigaunix | amix) + basic_machine=m68k-unknown + os=-sysv4 + ;; + apollo68) + basic_machine=m68k-apollo + os=-sysv + ;; + apollo68bsd) + basic_machine=m68k-apollo + os=-bsd + ;; + aros) + basic_machine=i386-pc + os=-aros + ;; + aux) + basic_machine=m68k-apple + os=-aux + ;; + balance) + basic_machine=ns32k-sequent + os=-dynix + ;; + blackfin) + basic_machine=bfin-unknown + os=-linux + ;; + blackfin-*) + basic_machine=bfin-`echo $basic_machine | sed 's/^[^-]*-//'` + os=-linux + ;; + bluegene*) + basic_machine=powerpc-ibm + os=-cnk + ;; + c54x-*) + basic_machine=tic54x-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + c55x-*) + basic_machine=tic55x-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + c6x-*) + basic_machine=tic6x-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + c90) + basic_machine=c90-cray + os=-unicos + ;; + cegcc) + basic_machine=arm-unknown + os=-cegcc + ;; + convex-c1) + basic_machine=c1-convex + os=-bsd + ;; + convex-c2) + basic_machine=c2-convex + os=-bsd + ;; + convex-c32) + basic_machine=c32-convex + os=-bsd + ;; + convex-c34) + basic_machine=c34-convex + os=-bsd + ;; + convex-c38) + basic_machine=c38-convex + os=-bsd + ;; + cray | j90) + basic_machine=j90-cray + os=-unicos + ;; + craynv) + basic_machine=craynv-cray + os=-unicosmp + ;; + cr16 | cr16-*) + basic_machine=cr16-unknown + os=-elf + ;; + crds | unos) + basic_machine=m68k-crds + ;; + crisv32 | crisv32-* | etraxfs*) + basic_machine=crisv32-axis + ;; + cris | cris-* | etrax*) + basic_machine=cris-axis + ;; + crx) + basic_machine=crx-unknown + os=-elf + ;; + da30 | da30-*) + basic_machine=m68k-da30 + ;; + decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn) + basic_machine=mips-dec + ;; + decsystem10* | dec10*) + basic_machine=pdp10-dec + os=-tops10 + ;; + decsystem20* | dec20*) + basic_machine=pdp10-dec + os=-tops20 + ;; + delta | 3300 | motorola-3300 | motorola-delta \ + | 3300-motorola | delta-motorola) + basic_machine=m68k-motorola + ;; + delta88) + basic_machine=m88k-motorola + os=-sysv3 + ;; + dicos) + basic_machine=i686-pc + os=-dicos + ;; + djgpp) + basic_machine=i586-pc + os=-msdosdjgpp + ;; + dpx20 | dpx20-*) + basic_machine=rs6000-bull + os=-bosx + ;; + dpx2* | dpx2*-bull) + basic_machine=m68k-bull + os=-sysv3 + ;; + ebmon29k) + basic_machine=a29k-amd + os=-ebmon + ;; + elxsi) + basic_machine=elxsi-elxsi + os=-bsd + ;; + encore | umax | mmax) + basic_machine=ns32k-encore + ;; + es1800 | OSE68k | ose68k | ose | OSE) + basic_machine=m68k-ericsson + os=-ose + ;; + fx2800) + basic_machine=i860-alliant + ;; + genix) + basic_machine=ns32k-ns + ;; + gmicro) + basic_machine=tron-gmicro + os=-sysv + ;; + go32) + basic_machine=i386-pc + os=-go32 + ;; + h3050r* | hiux*) + basic_machine=hppa1.1-hitachi + os=-hiuxwe2 + ;; + h8300hms) + basic_machine=h8300-hitachi + os=-hms + ;; + h8300xray) + basic_machine=h8300-hitachi + os=-xray + ;; + h8500hms) + basic_machine=h8500-hitachi + os=-hms + ;; + harris) + basic_machine=m88k-harris + os=-sysv3 + ;; + hp300-*) + basic_machine=m68k-hp + ;; + hp300bsd) + basic_machine=m68k-hp + os=-bsd + ;; + hp300hpux) + basic_machine=m68k-hp + os=-hpux + ;; + hp3k9[0-9][0-9] | hp9[0-9][0-9]) + basic_machine=hppa1.0-hp + ;; + hp9k2[0-9][0-9] | hp9k31[0-9]) + basic_machine=m68000-hp + ;; + hp9k3[2-9][0-9]) + basic_machine=m68k-hp + ;; + hp9k6[0-9][0-9] | hp6[0-9][0-9]) + basic_machine=hppa1.0-hp + ;; + hp9k7[0-79][0-9] | hp7[0-79][0-9]) + basic_machine=hppa1.1-hp + ;; + hp9k78[0-9] | hp78[0-9]) + # FIXME: really hppa2.0-hp + basic_machine=hppa1.1-hp + ;; + hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893) + # FIXME: really hppa2.0-hp + basic_machine=hppa1.1-hp + ;; + hp9k8[0-9][13679] | hp8[0-9][13679]) + basic_machine=hppa1.1-hp + ;; + hp9k8[0-9][0-9] | hp8[0-9][0-9]) + basic_machine=hppa1.0-hp + ;; + hppa-next) + os=-nextstep3 + ;; + hppaosf) + basic_machine=hppa1.1-hp + os=-osf + ;; + hppro) + basic_machine=hppa1.1-hp + os=-proelf + ;; + i370-ibm* | ibm*) + basic_machine=i370-ibm + ;; + i*86v32) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-sysv32 + ;; + i*86v4*) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-sysv4 + ;; + i*86v) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-sysv + ;; + i*86sol2) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-solaris2 + ;; + i386mach) + basic_machine=i386-mach + os=-mach + ;; + i386-vsta | vsta) + basic_machine=i386-unknown + os=-vsta + ;; + iris | iris4d) + basic_machine=mips-sgi + case $os in + -irix*) + ;; + *) + os=-irix4 + ;; + esac + ;; + isi68 | isi) + basic_machine=m68k-isi + os=-sysv + ;; + m68knommu) + basic_machine=m68k-unknown + os=-linux + ;; + m68knommu-*) + basic_machine=m68k-`echo $basic_machine | sed 's/^[^-]*-//'` + os=-linux + ;; + m88k-omron*) + basic_machine=m88k-omron + ;; + magnum | m3230) + basic_machine=mips-mips + os=-sysv + ;; + merlin) + basic_machine=ns32k-utek + os=-sysv + ;; + microblaze*) + basic_machine=microblaze-xilinx + ;; + mingw64) + basic_machine=x86_64-pc + os=-mingw64 + ;; + mingw32) + basic_machine=i686-pc + os=-mingw32 + ;; + mingw32ce) + basic_machine=arm-unknown + os=-mingw32ce + ;; + miniframe) + basic_machine=m68000-convergent + ;; + *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*) + basic_machine=m68k-atari + os=-mint + ;; + mips3*-*) + basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'` + ;; + mips3*) + basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown + ;; + monitor) + basic_machine=m68k-rom68k + os=-coff + ;; + morphos) + basic_machine=powerpc-unknown + os=-morphos + ;; + msdos) + basic_machine=i386-pc + os=-msdos + ;; + ms1-*) + basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'` + ;; + msys) + basic_machine=i686-pc + os=-msys + ;; + mvs) + basic_machine=i370-ibm + os=-mvs + ;; + nacl) + basic_machine=le32-unknown + os=-nacl + ;; + ncr3000) + basic_machine=i486-ncr + os=-sysv4 + ;; + netbsd386) + basic_machine=i386-unknown + os=-netbsd + ;; + netwinder) + basic_machine=armv4l-rebel + os=-linux + ;; + news | news700 | news800 | news900) + basic_machine=m68k-sony + os=-newsos + ;; + news1000) + basic_machine=m68030-sony + os=-newsos + ;; + news-3600 | risc-news) + basic_machine=mips-sony + os=-newsos + ;; + necv70) + basic_machine=v70-nec + os=-sysv + ;; + next | m*-next ) + basic_machine=m68k-next + case $os in + -nextstep* ) + ;; + -ns2*) + os=-nextstep2 + ;; + *) + os=-nextstep3 + ;; + esac + ;; + nh3000) + basic_machine=m68k-harris + os=-cxux + ;; + nh[45]000) + basic_machine=m88k-harris + os=-cxux + ;; + nindy960) + basic_machine=i960-intel + os=-nindy + ;; + mon960) + basic_machine=i960-intel + os=-mon960 + ;; + nonstopux) + basic_machine=mips-compaq + os=-nonstopux + ;; + np1) + basic_machine=np1-gould + ;; + neo-tandem) + basic_machine=neo-tandem + ;; + nse-tandem) + basic_machine=nse-tandem + ;; + nsr-tandem) + basic_machine=nsr-tandem + ;; + op50n-* | op60c-*) + basic_machine=hppa1.1-oki + os=-proelf + ;; + openrisc | openrisc-*) + basic_machine=or32-unknown + ;; + os400) + basic_machine=powerpc-ibm + os=-os400 + ;; + OSE68000 | ose68000) + basic_machine=m68000-ericsson + os=-ose + ;; + os68k) + basic_machine=m68k-none + os=-os68k + ;; + pa-hitachi) + basic_machine=hppa1.1-hitachi + os=-hiuxwe2 + ;; + paragon) + basic_machine=i860-intel + os=-osf + ;; + parisc) + basic_machine=hppa-unknown + os=-linux + ;; + parisc-*) + basic_machine=hppa-`echo $basic_machine | sed 's/^[^-]*-//'` + os=-linux + ;; + pbd) + basic_machine=sparc-tti + ;; + pbb) + basic_machine=m68k-tti + ;; + pc532 | pc532-*) + basic_machine=ns32k-pc532 + ;; + pc98) + basic_machine=i386-pc + ;; + pc98-*) + basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentium | p5 | k5 | k6 | nexgen | viac3) + basic_machine=i586-pc + ;; + pentiumpro | p6 | 6x86 | athlon | athlon_*) + basic_machine=i686-pc + ;; + pentiumii | pentium2 | pentiumiii | pentium3) + basic_machine=i686-pc + ;; + pentium4) + basic_machine=i786-pc + ;; + pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*) + basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentiumpro-* | p6-* | 6x86-* | athlon-*) + basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*) + basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentium4-*) + basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pn) + basic_machine=pn-gould + ;; + power) basic_machine=power-ibm + ;; + ppc | ppcbe) basic_machine=powerpc-unknown + ;; + ppc-* | ppcbe-*) + basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ppcle | powerpclittle | ppc-le | powerpc-little) + basic_machine=powerpcle-unknown + ;; + ppcle-* | powerpclittle-*) + basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ppc64) basic_machine=powerpc64-unknown + ;; + ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ppc64le | powerpc64little | ppc64-le | powerpc64-little) + basic_machine=powerpc64le-unknown + ;; + ppc64le-* | powerpc64little-*) + basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ps2) + basic_machine=i386-ibm + ;; + pw32) + basic_machine=i586-unknown + os=-pw32 + ;; + rdos | rdos64) + basic_machine=x86_64-pc + os=-rdos + ;; + rdos32) + basic_machine=i386-pc + os=-rdos + ;; + rom68k) + basic_machine=m68k-rom68k + os=-coff + ;; + rm[46]00) + basic_machine=mips-siemens + ;; + rtpc | rtpc-*) + basic_machine=romp-ibm + ;; + s390 | s390-*) + basic_machine=s390-ibm + ;; + s390x | s390x-*) + basic_machine=s390x-ibm + ;; + sa29200) + basic_machine=a29k-amd + os=-udi + ;; + sb1) + basic_machine=mipsisa64sb1-unknown + ;; + sb1el) + basic_machine=mipsisa64sb1el-unknown + ;; + sde) + basic_machine=mipsisa32-sde + os=-elf + ;; + sei) + basic_machine=mips-sei + os=-seiux + ;; + sequent) + basic_machine=i386-sequent + ;; + sh) + basic_machine=sh-hitachi + os=-hms + ;; + sh5el) + basic_machine=sh5le-unknown + ;; + sh64) + basic_machine=sh64-unknown + ;; + sparclite-wrs | simso-wrs) + basic_machine=sparclite-wrs + os=-vxworks + ;; + sps7) + basic_machine=m68k-bull + os=-sysv2 + ;; + spur) + basic_machine=spur-unknown + ;; + st2000) + basic_machine=m68k-tandem + ;; + stratus) + basic_machine=i860-stratus + os=-sysv4 + ;; + strongarm-* | thumb-*) + basic_machine=arm-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + sun2) + basic_machine=m68000-sun + ;; + sun2os3) + basic_machine=m68000-sun + os=-sunos3 + ;; + sun2os4) + basic_machine=m68000-sun + os=-sunos4 + ;; + sun3os3) + basic_machine=m68k-sun + os=-sunos3 + ;; + sun3os4) + basic_machine=m68k-sun + os=-sunos4 + ;; + sun4os3) + basic_machine=sparc-sun + os=-sunos3 + ;; + sun4os4) + basic_machine=sparc-sun + os=-sunos4 + ;; + sun4sol2) + basic_machine=sparc-sun + os=-solaris2 + ;; + sun3 | sun3-*) + basic_machine=m68k-sun + ;; + sun4) + basic_machine=sparc-sun + ;; + sun386 | sun386i | roadrunner) + basic_machine=i386-sun + ;; + sv1) + basic_machine=sv1-cray + os=-unicos + ;; + symmetry) + basic_machine=i386-sequent + os=-dynix + ;; + t3e) + basic_machine=alphaev5-cray + os=-unicos + ;; + t90) + basic_machine=t90-cray + os=-unicos + ;; + tile*) + basic_machine=$basic_machine-unknown + os=-linux-gnu + ;; + tx39) + basic_machine=mipstx39-unknown + ;; + tx39el) + basic_machine=mipstx39el-unknown + ;; + toad1) + basic_machine=pdp10-xkl + os=-tops20 + ;; + tower | tower-32) + basic_machine=m68k-ncr + ;; + tpf) + basic_machine=s390x-ibm + os=-tpf + ;; + udi29k) + basic_machine=a29k-amd + os=-udi + ;; + ultra3) + basic_machine=a29k-nyu + os=-sym1 + ;; + v810 | necv810) + basic_machine=v810-nec + os=-none + ;; + vaxv) + basic_machine=vax-dec + os=-sysv + ;; + vms) + basic_machine=vax-dec + os=-vms + ;; + vpp*|vx|vx-*) + basic_machine=f301-fujitsu + ;; + vxworks960) + basic_machine=i960-wrs + os=-vxworks + ;; + vxworks68) + basic_machine=m68k-wrs + os=-vxworks + ;; + vxworks29k) + basic_machine=a29k-wrs + os=-vxworks + ;; + w65*) + basic_machine=w65-wdc + os=-none + ;; + w89k-*) + basic_machine=hppa1.1-winbond + os=-proelf + ;; + xbox) + basic_machine=i686-pc + os=-mingw32 + ;; + xps | xps100) + basic_machine=xps100-honeywell + ;; + xscale-* | xscalee[bl]-*) + basic_machine=`echo $basic_machine | sed 's/^xscale/arm/'` + ;; + ymp) + basic_machine=ymp-cray + os=-unicos + ;; + z8k-*-coff) + basic_machine=z8k-unknown + os=-sim + ;; + z80-*-coff) + basic_machine=z80-unknown + os=-sim + ;; + none) + basic_machine=none-none + os=-none + ;; + +# Here we handle the default manufacturer of certain CPU types. It is in +# some cases the only manufacturer, in others, it is the most popular. + w89k) + basic_machine=hppa1.1-winbond + ;; + op50n) + basic_machine=hppa1.1-oki + ;; + op60c) + basic_machine=hppa1.1-oki + ;; + romp) + basic_machine=romp-ibm + ;; + mmix) + basic_machine=mmix-knuth + ;; + rs6000) + basic_machine=rs6000-ibm + ;; + vax) + basic_machine=vax-dec + ;; + pdp10) + # there are many clones, so DEC is not a safe bet + basic_machine=pdp10-unknown + ;; + pdp11) + basic_machine=pdp11-dec + ;; + we32k) + basic_machine=we32k-att + ;; + sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele) + basic_machine=sh-unknown + ;; + sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v) + basic_machine=sparc-sun + ;; + cydra) + basic_machine=cydra-cydrome + ;; + orion) + basic_machine=orion-highlevel + ;; + orion105) + basic_machine=clipper-highlevel + ;; + mac | mpw | mac-mpw) + basic_machine=m68k-apple + ;; + pmac | pmac-mpw) + basic_machine=powerpc-apple + ;; + *-unknown) + # Make sure to match an already-canonicalized machine name. + ;; + *) + echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 + exit 1 + ;; +esac + +# Here we canonicalize certain aliases for manufacturers. +case $basic_machine in + *-digital*) + basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'` + ;; + *-commodore*) + basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'` + ;; + *) + ;; +esac + +# Decode manufacturer-specific aliases for certain operating systems. + +if [ x"$os" != x"" ] +then +case $os in + # First match some system type aliases + # that might get confused with valid system types. + # -solaris* is a basic system type, with this one exception. + -auroraux) + os=-auroraux + ;; + -solaris1 | -solaris1.*) + os=`echo $os | sed -e 's|solaris1|sunos4|'` + ;; + -solaris) + os=-solaris2 + ;; + -svr4*) + os=-sysv4 + ;; + -unixware*) + os=-sysv4.2uw + ;; + -gnu/linux*) + os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'` + ;; + # First accept the basic system types. + # The portable systems comes first. + # Each alternative MUST END IN A *, to match a version number. + # -sysv* is not here because it comes later, after sysvr4. + -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \ + | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\ + | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \ + | -sym* | -kopensolaris* | -plan9* \ + | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \ + | -aos* | -aros* \ + | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \ + | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \ + | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \ + | -bitrig* | -openbsd* | -solidbsd* \ + | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \ + | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \ + | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \ + | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \ + | -chorusos* | -chorusrdb* | -cegcc* \ + | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \ + | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \ + | -linux-newlib* | -linux-musl* | -linux-uclibc* \ + | -uxpv* | -beos* | -mpeix* | -udk* \ + | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \ + | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \ + | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \ + | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \ + | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \ + | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \ + | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es*) + # Remember, each alternative MUST END IN *, to match a version number. + ;; + -qnx*) + case $basic_machine in + x86-* | i*86-*) + ;; + *) + os=-nto$os + ;; + esac + ;; + -nto-qnx*) + ;; + -nto*) + os=`echo $os | sed -e 's|nto|nto-qnx|'` + ;; + -sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \ + | -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \ + | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*) + ;; + -mac*) + os=`echo $os | sed -e 's|mac|macos|'` + ;; + -linux-dietlibc) + os=-linux-dietlibc + ;; + -linux*) + os=`echo $os | sed -e 's|linux|linux-gnu|'` + ;; + -sunos5*) + os=`echo $os | sed -e 's|sunos5|solaris2|'` + ;; + -sunos6*) + os=`echo $os | sed -e 's|sunos6|solaris3|'` + ;; + -opened*) + os=-openedition + ;; + -os400*) + os=-os400 + ;; + -wince*) + os=-wince + ;; + -osfrose*) + os=-osfrose + ;; + -osf*) + os=-osf + ;; + -utek*) + os=-bsd + ;; + -dynix*) + os=-bsd + ;; + -acis*) + os=-aos + ;; + -atheos*) + os=-atheos + ;; + -syllable*) + os=-syllable + ;; + -386bsd) + os=-bsd + ;; + -ctix* | -uts*) + os=-sysv + ;; + -nova*) + os=-rtmk-nova + ;; + -ns2 ) + os=-nextstep2 + ;; + -nsk*) + os=-nsk + ;; + # Preserve the version number of sinix5. + -sinix5.*) + os=`echo $os | sed -e 's|sinix|sysv|'` + ;; + -sinix*) + os=-sysv4 + ;; + -tpf*) + os=-tpf + ;; + -triton*) + os=-sysv3 + ;; + -oss*) + os=-sysv3 + ;; + -svr4) + os=-sysv4 + ;; + -svr3) + os=-sysv3 + ;; + -sysvr4) + os=-sysv4 + ;; + # This must come after -sysvr4. + -sysv*) + ;; + -ose*) + os=-ose + ;; + -es1800*) + os=-ose + ;; + -xenix) + os=-xenix + ;; + -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) + os=-mint + ;; + -aros*) + os=-aros + ;; + -zvmoe) + os=-zvmoe + ;; + -dicos*) + os=-dicos + ;; + -nacl*) + ;; + -none) + ;; + *) + # Get rid of the `-' at the beginning of $os. + os=`echo $os | sed 's/[^-]*-//'` + echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2 + exit 1 + ;; +esac +else + +# Here we handle the default operating systems that come with various machines. +# The value should be what the vendor currently ships out the door with their +# machine or put another way, the most popular os provided with the machine. + +# Note that if you're going to try to match "-MANUFACTURER" here (say, +# "-sun"), then you have to tell the case statement up towards the top +# that MANUFACTURER isn't an operating system. Otherwise, code above +# will signal an error saying that MANUFACTURER isn't an operating +# system, and we'll never get to this point. + +case $basic_machine in + score-*) + os=-elf + ;; + spu-*) + os=-elf + ;; + *-acorn) + os=-riscix1.2 + ;; + arm*-rebel) + os=-linux + ;; + arm*-semi) + os=-aout + ;; + c4x-* | tic4x-*) + os=-coff + ;; + c8051-*) + os=-elf + ;; + hexagon-*) + os=-elf + ;; + tic54x-*) + os=-coff + ;; + tic55x-*) + os=-coff + ;; + tic6x-*) + os=-coff + ;; + # This must come before the *-dec entry. + pdp10-*) + os=-tops20 + ;; + pdp11-*) + os=-none + ;; + *-dec | vax-*) + os=-ultrix4.2 + ;; + m68*-apollo) + os=-domain + ;; + i386-sun) + os=-sunos4.0.2 + ;; + m68000-sun) + os=-sunos3 + ;; + m68*-cisco) + os=-aout + ;; + mep-*) + os=-elf + ;; + mips*-cisco) + os=-elf + ;; + mips*-*) + os=-elf + ;; + or1k-*) + os=-elf + ;; + or32-*) + os=-coff + ;; + *-tti) # must be before sparc entry or we get the wrong os. + os=-sysv3 + ;; + sparc-* | *-sun) + os=-sunos4.1.1 + ;; + *-be) + os=-beos + ;; + *-haiku) + os=-haiku + ;; + *-ibm) + os=-aix + ;; + *-knuth) + os=-mmixware + ;; + *-wec) + os=-proelf + ;; + *-winbond) + os=-proelf + ;; + *-oki) + os=-proelf + ;; + *-hp) + os=-hpux + ;; + *-hitachi) + os=-hiux + ;; + i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent) + os=-sysv + ;; + *-cbm) + os=-amigaos + ;; + *-dg) + os=-dgux + ;; + *-dolphin) + os=-sysv3 + ;; + m68k-ccur) + os=-rtu + ;; + m88k-omron*) + os=-luna + ;; + *-next ) + os=-nextstep + ;; + *-sequent) + os=-ptx + ;; + *-crds) + os=-unos + ;; + *-ns) + os=-genix + ;; + i370-*) + os=-mvs + ;; + *-next) + os=-nextstep3 + ;; + *-gould) + os=-sysv + ;; + *-highlevel) + os=-bsd + ;; + *-encore) + os=-bsd + ;; + *-sgi) + os=-irix + ;; + *-siemens) + os=-sysv4 + ;; + *-masscomp) + os=-rtu + ;; + f30[01]-fujitsu | f700-fujitsu) + os=-uxpv + ;; + *-rom68k) + os=-coff + ;; + *-*bug) + os=-coff + ;; + *-apple) + os=-macos + ;; + *-atari*) + os=-mint + ;; + *) + os=-none + ;; +esac +fi + +# Here we handle the case where we know the os, and the CPU type, but not the +# manufacturer. We pick the logical manufacturer. +vendor=unknown +case $basic_machine in + *-unknown) + case $os in + -riscix*) + vendor=acorn + ;; + -sunos*) + vendor=sun + ;; + -cnk*|-aix*) + vendor=ibm + ;; + -beos*) + vendor=be + ;; + -hpux*) + vendor=hp + ;; + -mpeix*) + vendor=hp + ;; + -hiux*) + vendor=hitachi + ;; + -unos*) + vendor=crds + ;; + -dgux*) + vendor=dg + ;; + -luna*) + vendor=omron + ;; + -genix*) + vendor=ns + ;; + -mvs* | -opened*) + vendor=ibm + ;; + -os400*) + vendor=ibm + ;; + -ptx*) + vendor=sequent + ;; + -tpf*) + vendor=ibm + ;; + -vxsim* | -vxworks* | -windiss*) + vendor=wrs + ;; + -aux*) + vendor=apple + ;; + -hms*) + vendor=hitachi + ;; + -mpw* | -macos*) + vendor=apple + ;; + -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) + vendor=atari + ;; + -vos*) + vendor=stratus + ;; + esac + basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"` + ;; +esac + +echo $basic_machine$os +exit + +# Local variables: +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "timestamp='" +# time-stamp-format: "%:y-%02m-%02d" +# time-stamp-end: "'" +# End: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/configure b/native_client/ctcdecode/third_party/openfst-1.6.7/configure new file mode 100755 index 0000000000..2a9d0dba70 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/configure @@ -0,0 +1,18870 @@ +#! /bin/sh +# Guess values for system-dependent variables and create Makefiles. +# Generated by GNU Autoconf 2.69 for OpenFst 1.6.7. +# +# Report bugs to . +# +# +# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. +# +# +# This configure script is free software; the Free Software Foundation +# gives unlimited permission to copy, distribute and modify it. +## -------------------- ## +## M4sh Initialization. ## +## -------------------- ## + +# Be more Bourne compatible +DUALCASE=1; export DUALCASE # for MKS sh +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' + setopt NO_GLOB_SUBST +else + case `(set -o) 2>/dev/null` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi + + +as_nl=' +' +export as_nl +# Printing a long string crashes Solaris 7 /usr/bin/printf. +as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo +# Prefer a ksh shell builtin over an external printf program on Solaris, +# but without wasting forks for bash or zsh. +if test -z "$BASH_VERSION$ZSH_VERSION" \ + && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='print -r --' + as_echo_n='print -rn --' +elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='printf %s\n' + as_echo_n='printf %s' +else + if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then + as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' + as_echo_n='/usr/ucb/echo -n' + else + as_echo_body='eval expr "X$1" : "X\\(.*\\)"' + as_echo_n_body='eval + arg=$1; + case $arg in #( + *"$as_nl"*) + expr "X$arg" : "X\\(.*\\)$as_nl"; + arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; + esac; + expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" + ' + export as_echo_n_body + as_echo_n='sh -c $as_echo_n_body as_echo' + fi + export as_echo_body + as_echo='sh -c $as_echo_body as_echo' +fi + +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || + PATH_SEPARATOR=';' + } +fi + + +# IFS +# We need space, tab and new line, in precisely that order. Quoting is +# there to prevent editors from complaining about space-tab. +# (If _AS_PATH_WALK were called with IFS unset, it would disable word +# splitting by setting IFS to empty value.) +IFS=" "" $as_nl" + +# Find who we are. Look in the path if we contain no directory separator. +as_myself= +case $0 in #(( + *[\\/]* ) as_myself=$0 ;; + *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + done +IFS=$as_save_IFS + + ;; +esac +# We did not find ourselves, most probably we were run as `sh COMMAND' +# in which case we are not to be found in the path. +if test "x$as_myself" = x; then + as_myself=$0 +fi +if test ! -f "$as_myself"; then + $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + exit 1 +fi + +# Unset variables that we do not need and which cause bugs (e.g. in +# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" +# suppresses any "Segmentation fault" message there. '((' could +# trigger a bug in pdksh 5.2.14. +for as_var in BASH_ENV ENV MAIL MAILPATH +do eval test x\${$as_var+set} = xset \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# CDPATH. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + +# Use a proper internal environment variable to ensure we don't fall + # into an infinite loop, continuously re-executing ourselves. + if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then + _as_can_reexec=no; export _as_can_reexec; + # We cannot yet assume a decent shell, so we have to provide a +# neutralization value for shells without unset; and this also +# works around shells that cannot unset nonexistent variables. +# Preserve -v and -x to the replacement shell. +BASH_ENV=/dev/null +ENV=/dev/null +(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV +case $- in # (((( + *v*x* | *x*v* ) as_opts=-vx ;; + *v* ) as_opts=-v ;; + *x* ) as_opts=-x ;; + * ) as_opts= ;; +esac +exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} +# Admittedly, this is quite paranoid, since all the known shells bail +# out after a failed `exec'. +$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 +as_fn_exit 255 + fi + # We don't want this to propagate to other subprocesses. + { _as_can_reexec=; unset _as_can_reexec;} +if test "x$CONFIG_SHELL" = x; then + as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which + # is contrary to our usage. Disable this feature. + alias -g '\${1+\"\$@\"}'='\"\$@\"' + setopt NO_GLOB_SUBST +else + case \`(set -o) 2>/dev/null\` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi +" + as_required="as_fn_return () { (exit \$1); } +as_fn_success () { as_fn_return 0; } +as_fn_failure () { as_fn_return 1; } +as_fn_ret_success () { return 0; } +as_fn_ret_failure () { return 1; } + +exitcode=0 +as_fn_success || { exitcode=1; echo as_fn_success failed.; } +as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } +as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } +as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } +if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : + +else + exitcode=1; echo positional parameters were not saved. +fi +test x\$exitcode = x0 || exit 1 +test -x / || exit 1" + as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO + as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO + eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && + test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1 + + test -n \"\${ZSH_VERSION+set}\${BASH_VERSION+set}\" || ( + ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO + ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO + PATH=/empty FPATH=/empty; export PATH FPATH + test \"X\`printf %s \$ECHO\`\" = \"X\$ECHO\" \\ + || test \"X\`print -r -- \$ECHO\`\" = \"X\$ECHO\" ) || exit 1 +test \$(( 1 + 1 )) = 2 || exit 1" + if (eval "$as_required") 2>/dev/null; then : + as_have_required=yes +else + as_have_required=no +fi + if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : + +else + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +as_found=false +for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + as_found=: + case $as_dir in #( + /*) + for as_base in sh bash ksh sh5; do + # Try only shells that exist, to save several forks. + as_shell=$as_dir/$as_base + if { test -f "$as_shell" || test -f "$as_shell.exe"; } && + { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : + CONFIG_SHELL=$as_shell as_have_required=yes + if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : + break 2 +fi +fi + done;; + esac + as_found=false +done +$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && + { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : + CONFIG_SHELL=$SHELL as_have_required=yes +fi; } +IFS=$as_save_IFS + + + if test "x$CONFIG_SHELL" != x; then : + export CONFIG_SHELL + # We cannot yet assume a decent shell, so we have to provide a +# neutralization value for shells without unset; and this also +# works around shells that cannot unset nonexistent variables. +# Preserve -v and -x to the replacement shell. +BASH_ENV=/dev/null +ENV=/dev/null +(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV +case $- in # (((( + *v*x* | *x*v* ) as_opts=-vx ;; + *v* ) as_opts=-v ;; + *x* ) as_opts=-x ;; + * ) as_opts= ;; +esac +exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} +# Admittedly, this is quite paranoid, since all the known shells bail +# out after a failed `exec'. +$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 +exit 255 +fi + + if test x$as_have_required = xno; then : + $as_echo "$0: This script requires a shell more modern than all" + $as_echo "$0: the shells that I found on your system." + if test x${ZSH_VERSION+set} = xset ; then + $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" + $as_echo "$0: be upgraded to zsh 4.3.4 or later." + else + $as_echo "$0: Please tell bug-autoconf@gnu.org and +$0: help@www.openfst.org about your system, including any +$0: error possibly output before this message. Then install +$0: a modern shell, or manually run the script under such a +$0: shell if you do have one." + fi + exit 1 +fi +fi +fi +SHELL=${CONFIG_SHELL-/bin/sh} +export SHELL +# Unset more variables known to interfere with behavior of common tools. +CLICOLOR_FORCE= GREP_OPTIONS= +unset CLICOLOR_FORCE GREP_OPTIONS + +## --------------------- ## +## M4sh Shell Functions. ## +## --------------------- ## +# as_fn_unset VAR +# --------------- +# Portably unset VAR. +as_fn_unset () +{ + { eval $1=; unset $1;} +} +as_unset=as_fn_unset + +# as_fn_set_status STATUS +# ----------------------- +# Set $? to STATUS, without forking. +as_fn_set_status () +{ + return $1 +} # as_fn_set_status + +# as_fn_exit STATUS +# ----------------- +# Exit the shell with STATUS, even in a "trap 0" or "set -e" context. +as_fn_exit () +{ + set +e + as_fn_set_status $1 + exit $1 +} # as_fn_exit + +# as_fn_mkdir_p +# ------------- +# Create "$as_dir" as a directory, including parents if necessary. +as_fn_mkdir_p () +{ + + case $as_dir in #( + -*) as_dir=./$as_dir;; + esac + test -d "$as_dir" || eval $as_mkdir_p || { + as_dirs= + while :; do + case $as_dir in #( + *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *) as_qdir=$as_dir;; + esac + as_dirs="'$as_qdir' $as_dirs" + as_dir=`$as_dirname -- "$as_dir" || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + test -d "$as_dir" && break + done + test -z "$as_dirs" || eval "mkdir $as_dirs" + } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" + + +} # as_fn_mkdir_p + +# as_fn_executable_p FILE +# ----------------------- +# Test if FILE is an executable regular file. +as_fn_executable_p () +{ + test -f "$1" && test -x "$1" +} # as_fn_executable_p +# as_fn_append VAR VALUE +# ---------------------- +# Append the text in VALUE to the end of the definition contained in VAR. Take +# advantage of any shell optimizations that allow amortized linear growth over +# repeated appends, instead of the typical quadratic growth present in naive +# implementations. +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : + eval 'as_fn_append () + { + eval $1+=\$2 + }' +else + as_fn_append () + { + eval $1=\$$1\$2 + } +fi # as_fn_append + +# as_fn_arith ARG... +# ------------------ +# Perform arithmetic evaluation on the ARGs, and store the result in the +# global $as_val. Take advantage of shells that can avoid forks. The arguments +# must be portable across $(()) and expr. +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : + eval 'as_fn_arith () + { + as_val=$(( $* )) + }' +else + as_fn_arith () + { + as_val=`expr "$@" || test $? -eq 1` + } +fi # as_fn_arith + + +# as_fn_error STATUS ERROR [LINENO LOG_FD] +# ---------------------------------------- +# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are +# provided, also output the error to LOG_FD, referencing LINENO. Then exit the +# script with STATUS, using 1 if that was 0. +as_fn_error () +{ + as_status=$1; test $as_status -eq 0 && as_status=1 + if test "$4"; then + as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + fi + $as_echo "$as_me: error: $2" >&2 + as_fn_exit $as_status +} # as_fn_error + +if expr a : '\(a\)' >/dev/null 2>&1 && + test "X`expr 00001 : '.*\(...\)'`" = X001; then + as_expr=expr +else + as_expr=false +fi + +if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi + +if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then + as_dirname=dirname +else + as_dirname=false +fi + +as_me=`$as_basename -- "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ + s//\1/ + q + } + /^X\/\(\/\/\)$/{ + s//\1/ + q + } + /^X\/\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits + + + as_lineno_1=$LINENO as_lineno_1a=$LINENO + as_lineno_2=$LINENO as_lineno_2a=$LINENO + eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && + test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { + # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) + sed -n ' + p + /[$]LINENO/= + ' <$as_myself | + sed ' + s/[$]LINENO.*/&-/ + t lineno + b + :lineno + N + :loop + s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ + t loop + s/-\n.*// + ' >$as_me.lineno && + chmod +x "$as_me.lineno" || + { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } + + # If we had to re-execute with $CONFIG_SHELL, we're ensured to have + # already done that, so ensure we don't try to do so again and fall + # in an infinite loop. This has already happened in practice. + _as_can_reexec=no; export _as_can_reexec + # Don't try to exec as it changes $[0], causing all sort of problems + # (the dirname of $[0] is not the place where we might find the + # original and so on. Autoconf is especially sensitive to this). + . "./$as_me.lineno" + # Exit status is that of the last command. + exit +} + +ECHO_C= ECHO_N= ECHO_T= +case `echo -n x` in #((((( +-n*) + case `echo 'xy\c'` in + *c*) ECHO_T=' ';; # ECHO_T is single tab character. + xy) ECHO_C='\c';; + *) echo `echo ksh88 bug on AIX 6.1` > /dev/null + ECHO_T=' ';; + esac;; +*) + ECHO_N='-n';; +esac + +rm -f conf$$ conf$$.exe conf$$.file +if test -d conf$$.dir; then + rm -f conf$$.dir/conf$$.file +else + rm -f conf$$.dir + mkdir conf$$.dir 2>/dev/null +fi +if (echo >conf$$.file) 2>/dev/null; then + if ln -s conf$$.file conf$$ 2>/dev/null; then + as_ln_s='ln -s' + # ... but there are two gotchas: + # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. + # In both cases, we have to default to `cp -pR'. + ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + as_ln_s='cp -pR' + elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln + else + as_ln_s='cp -pR' + fi +else + as_ln_s='cp -pR' +fi +rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file +rmdir conf$$.dir 2>/dev/null + +if mkdir -p . 2>/dev/null; then + as_mkdir_p='mkdir -p "$as_dir"' +else + test -d ./-p && rmdir ./-p + as_mkdir_p=false +fi + +as_test_x='test -x' +as_executable_p=as_fn_executable_p + +# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" + +# Sed expression to map a string onto a valid variable name. +as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" + +SHELL=${CONFIG_SHELL-/bin/sh} + + +test -n "$DJDIR" || exec 7<&0 &1 + +# Name of the host. +# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status, +# so uname gets run too. +ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` + +# +# Initializations. +# +ac_default_prefix=/usr/local +ac_clean_files= +ac_config_libobj_dir=. +LIBOBJS= +cross_compiling=no +subdirs= +MFLAGS= +MAKEFLAGS= + +# Identity of this package. +PACKAGE_NAME='OpenFst' +PACKAGE_TARNAME='openfst' +PACKAGE_VERSION='1.6.7' +PACKAGE_STRING='OpenFst 1.6.7' +PACKAGE_BUGREPORT='help@www.openfst.org' +PACKAGE_URL='' + +# Factoring default headers for most tests. +ac_includes_default="\ +#include +#ifdef HAVE_SYS_TYPES_H +# include +#endif +#ifdef HAVE_SYS_STAT_H +# include +#endif +#ifdef STDC_HEADERS +# include +# include +#else +# ifdef HAVE_STDLIB_H +# include +# endif +#endif +#ifdef HAVE_STRING_H +# if !defined STDC_HEADERS && defined HAVE_MEMORY_H +# include +# endif +# include +#endif +#ifdef HAVE_STRINGS_H +# include +#endif +#ifdef HAVE_INTTYPES_H +# include +#endif +#ifdef HAVE_STDINT_H +# include +#endif +#ifdef HAVE_UNISTD_H +# include +#endif" + +ac_unique_file="src/lib/fst.cc" +ac_subst_vars='am__EXEEXT_FALSE +am__EXEEXT_TRUE +LTLIBOBJS +LIBOBJS +DL_LIBS +libfstdir +HAVE_GRM_FALSE +HAVE_GRM_TRUE +HAVE_SCRIPT_FALSE +HAVE_SCRIPT_TRUE +HAVE_BIN_FALSE +HAVE_BIN_TRUE +HAVE_SPECIAL_FALSE +HAVE_SPECIAL_TRUE +PYTHON_EXTRA_LDFLAGS +PYTHON_EXTRA_LIBS +PYTHON_SITE_PKG +PYTHON_LDFLAGS +PYTHON_CPPFLAGS +pkgpyexecdir +pyexecdir +pkgpythondir +pythondir +PYTHON_PLATFORM +PYTHON_EXEC_PREFIX +PYTHON_PREFIX +PYTHON_VERSION +PYTHON +HAVE_PYTHON_FALSE +HAVE_PYTHON_TRUE +HAVE_PDT_FALSE +HAVE_PDT_TRUE +HAVE_NGRAM_FALSE +HAVE_NGRAM_TRUE +HAVE_MPDT_FALSE +HAVE_MPDT_TRUE +HAVE_LOOKAHEAD_FALSE +HAVE_LOOKAHEAD_TRUE +HAVE_LINEAR_FALSE +HAVE_LINEAR_TRUE +HAVE_FAR_FALSE +HAVE_FAR_TRUE +HAVE_CONST_FALSE +HAVE_CONST_TRUE +HAVE_COMPRESS_FALSE +HAVE_COMPRESS_TRUE +HAVE_COMPACT_FALSE +HAVE_COMPACT_TRUE +CXXCPP +CPP +OTOOL64 +OTOOL +LIPO +NMEDIT +DSYMUTIL +MANIFEST_TOOL +RANLIB +DLLTOOL +OBJDUMP +LN_S +NM +ac_ct_DUMPBIN +DUMPBIN +LD +FGREP +EGREP +GREP +SED +host_os +host_vendor +host_cpu +host +build_os +build_vendor +build_cpu +build +LIBTOOL +am__fastdepCXX_FALSE +am__fastdepCXX_TRUE +CXXDEPMODE +ac_ct_CXX +CXXFLAGS +CXX +am__fastdepCC_FALSE +am__fastdepCC_TRUE +CCDEPMODE +am__nodep +AMDEPBACKSLASH +AMDEP_FALSE +AMDEP_TRUE +am__quote +am__include +DEPDIR +OBJEXT +EXEEXT +ac_ct_CC +CPPFLAGS +LDFLAGS +CFLAGS +CC +ac_ct_AR +AR +AM_BACKSLASH +AM_DEFAULT_VERBOSITY +AM_DEFAULT_V +AM_V +am__untar +am__tar +AMTAR +am__leading_dot +SET_MAKE +AWK +mkdir_p +MKDIR_P +INSTALL_STRIP_PROGRAM +STRIP +install_sh +MAKEINFO +AUTOHEADER +AUTOMAKE +AUTOCONF +ACLOCAL +VERSION +PACKAGE +CYGPATH_W +am__isrc +INSTALL_DATA +INSTALL_SCRIPT +INSTALL_PROGRAM +target_alias +host_alias +build_alias +LIBS +ECHO_T +ECHO_N +ECHO_C +DEFS +mandir +localedir +libdir +psdir +pdfdir +dvidir +htmldir +infodir +docdir +oldincludedir +includedir +localstatedir +sharedstatedir +sysconfdir +datadir +datarootdir +libexecdir +sbindir +bindir +program_transform_name +prefix +exec_prefix +PACKAGE_URL +PACKAGE_BUGREPORT +PACKAGE_STRING +PACKAGE_VERSION +PACKAGE_TARNAME +PACKAGE_NAME +PATH_SEPARATOR +SHELL' +ac_subst_files='' +ac_user_opts=' +enable_option_checking +enable_silent_rules +enable_dependency_tracking +enable_static +enable_shared +with_pic +enable_fast_install +with_gnu_ld +with_sysroot +enable_libtool_lock +enable_compact_fsts +enable_compress +enable_const_fsts +enable_far +enable_linear_fsts +enable_lookahead_fsts +enable_mpdt +enable_ngram_fsts +enable_pdt +enable_python +enable_special +enable_bin +enable_grm +with_libfstdir +' + ac_precious_vars='build_alias +host_alias +target_alias +CC +CFLAGS +LDFLAGS +LIBS +CPPFLAGS +CXX +CXXFLAGS +CCC +CPP +CXXCPP +PYTHON +PYTHON_VERSION' + + +# Initialize some variables set by options. +ac_init_help= +ac_init_version=false +ac_unrecognized_opts= +ac_unrecognized_sep= +# The variables have the same names as the options, with +# dashes changed to underlines. +cache_file=/dev/null +exec_prefix=NONE +no_create= +no_recursion= +prefix=NONE +program_prefix=NONE +program_suffix=NONE +program_transform_name=s,x,x, +silent= +site= +srcdir= +verbose= +x_includes=NONE +x_libraries=NONE + +# Installation directory options. +# These are left unexpanded so users can "make install exec_prefix=/foo" +# and all the variables that are supposed to be based on exec_prefix +# by default will actually change. +# Use braces instead of parens because sh, perl, etc. also accept them. +# (The list follows the same order as the GNU Coding Standards.) +bindir='${exec_prefix}/bin' +sbindir='${exec_prefix}/sbin' +libexecdir='${exec_prefix}/libexec' +datarootdir='${prefix}/share' +datadir='${datarootdir}' +sysconfdir='${prefix}/etc' +sharedstatedir='${prefix}/com' +localstatedir='${prefix}/var' +includedir='${prefix}/include' +oldincludedir='/usr/include' +docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' +infodir='${datarootdir}/info' +htmldir='${docdir}' +dvidir='${docdir}' +pdfdir='${docdir}' +psdir='${docdir}' +libdir='${exec_prefix}/lib' +localedir='${datarootdir}/locale' +mandir='${datarootdir}/man' + +ac_prev= +ac_dashdash= +for ac_option +do + # If the previous option needs an argument, assign it. + if test -n "$ac_prev"; then + eval $ac_prev=\$ac_option + ac_prev= + continue + fi + + case $ac_option in + *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;; + *=) ac_optarg= ;; + *) ac_optarg=yes ;; + esac + + # Accept the important Cygnus configure options, so we can diagnose typos. + + case $ac_dashdash$ac_option in + --) + ac_dashdash=yes ;; + + -bindir | --bindir | --bindi | --bind | --bin | --bi) + ac_prev=bindir ;; + -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) + bindir=$ac_optarg ;; + + -build | --build | --buil | --bui | --bu) + ac_prev=build_alias ;; + -build=* | --build=* | --buil=* | --bui=* | --bu=*) + build_alias=$ac_optarg ;; + + -cache-file | --cache-file | --cache-fil | --cache-fi \ + | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) + ac_prev=cache_file ;; + -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ + | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) + cache_file=$ac_optarg ;; + + --config-cache | -C) + cache_file=config.cache ;; + + -datadir | --datadir | --datadi | --datad) + ac_prev=datadir ;; + -datadir=* | --datadir=* | --datadi=* | --datad=*) + datadir=$ac_optarg ;; + + -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \ + | --dataroo | --dataro | --datar) + ac_prev=datarootdir ;; + -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \ + | --dataroot=* | --dataroo=* | --dataro=* | --datar=*) + datarootdir=$ac_optarg ;; + + -disable-* | --disable-*) + ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid feature name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"enable_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval enable_$ac_useropt=no ;; + + -docdir | --docdir | --docdi | --doc | --do) + ac_prev=docdir ;; + -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*) + docdir=$ac_optarg ;; + + -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv) + ac_prev=dvidir ;; + -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*) + dvidir=$ac_optarg ;; + + -enable-* | --enable-*) + ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid feature name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"enable_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval enable_$ac_useropt=\$ac_optarg ;; + + -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ + | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ + | --exec | --exe | --ex) + ac_prev=exec_prefix ;; + -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ + | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ + | --exec=* | --exe=* | --ex=*) + exec_prefix=$ac_optarg ;; + + -gas | --gas | --ga | --g) + # Obsolete; use --with-gas. + with_gas=yes ;; + + -help | --help | --hel | --he | -h) + ac_init_help=long ;; + -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) + ac_init_help=recursive ;; + -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) + ac_init_help=short ;; + + -host | --host | --hos | --ho) + ac_prev=host_alias ;; + -host=* | --host=* | --hos=* | --ho=*) + host_alias=$ac_optarg ;; + + -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht) + ac_prev=htmldir ;; + -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \ + | --ht=*) + htmldir=$ac_optarg ;; + + -includedir | --includedir | --includedi | --included | --include \ + | --includ | --inclu | --incl | --inc) + ac_prev=includedir ;; + -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ + | --includ=* | --inclu=* | --incl=* | --inc=*) + includedir=$ac_optarg ;; + + -infodir | --infodir | --infodi | --infod | --info | --inf) + ac_prev=infodir ;; + -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) + infodir=$ac_optarg ;; + + -libdir | --libdir | --libdi | --libd) + ac_prev=libdir ;; + -libdir=* | --libdir=* | --libdi=* | --libd=*) + libdir=$ac_optarg ;; + + -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ + | --libexe | --libex | --libe) + ac_prev=libexecdir ;; + -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ + | --libexe=* | --libex=* | --libe=*) + libexecdir=$ac_optarg ;; + + -localedir | --localedir | --localedi | --localed | --locale) + ac_prev=localedir ;; + -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*) + localedir=$ac_optarg ;; + + -localstatedir | --localstatedir | --localstatedi | --localstated \ + | --localstate | --localstat | --localsta | --localst | --locals) + ac_prev=localstatedir ;; + -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ + | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*) + localstatedir=$ac_optarg ;; + + -mandir | --mandir | --mandi | --mand | --man | --ma | --m) + ac_prev=mandir ;; + -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) + mandir=$ac_optarg ;; + + -nfp | --nfp | --nf) + # Obsolete; use --without-fp. + with_fp=no ;; + + -no-create | --no-create | --no-creat | --no-crea | --no-cre \ + | --no-cr | --no-c | -n) + no_create=yes ;; + + -no-recursion | --no-recursion | --no-recursio | --no-recursi \ + | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) + no_recursion=yes ;; + + -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ + | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ + | --oldin | --oldi | --old | --ol | --o) + ac_prev=oldincludedir ;; + -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ + | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ + | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) + oldincludedir=$ac_optarg ;; + + -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) + ac_prev=prefix ;; + -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) + prefix=$ac_optarg ;; + + -program-prefix | --program-prefix | --program-prefi | --program-pref \ + | --program-pre | --program-pr | --program-p) + ac_prev=program_prefix ;; + -program-prefix=* | --program-prefix=* | --program-prefi=* \ + | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) + program_prefix=$ac_optarg ;; + + -program-suffix | --program-suffix | --program-suffi | --program-suff \ + | --program-suf | --program-su | --program-s) + ac_prev=program_suffix ;; + -program-suffix=* | --program-suffix=* | --program-suffi=* \ + | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) + program_suffix=$ac_optarg ;; + + -program-transform-name | --program-transform-name \ + | --program-transform-nam | --program-transform-na \ + | --program-transform-n | --program-transform- \ + | --program-transform | --program-transfor \ + | --program-transfo | --program-transf \ + | --program-trans | --program-tran \ + | --progr-tra | --program-tr | --program-t) + ac_prev=program_transform_name ;; + -program-transform-name=* | --program-transform-name=* \ + | --program-transform-nam=* | --program-transform-na=* \ + | --program-transform-n=* | --program-transform-=* \ + | --program-transform=* | --program-transfor=* \ + | --program-transfo=* | --program-transf=* \ + | --program-trans=* | --program-tran=* \ + | --progr-tra=* | --program-tr=* | --program-t=*) + program_transform_name=$ac_optarg ;; + + -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd) + ac_prev=pdfdir ;; + -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*) + pdfdir=$ac_optarg ;; + + -psdir | --psdir | --psdi | --psd | --ps) + ac_prev=psdir ;; + -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) + psdir=$ac_optarg ;; + + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + silent=yes ;; + + -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) + ac_prev=sbindir ;; + -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ + | --sbi=* | --sb=*) + sbindir=$ac_optarg ;; + + -sharedstatedir | --sharedstatedir | --sharedstatedi \ + | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ + | --sharedst | --shareds | --shared | --share | --shar \ + | --sha | --sh) + ac_prev=sharedstatedir ;; + -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ + | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ + | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ + | --sha=* | --sh=*) + sharedstatedir=$ac_optarg ;; + + -site | --site | --sit) + ac_prev=site ;; + -site=* | --site=* | --sit=*) + site=$ac_optarg ;; + + -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) + ac_prev=srcdir ;; + -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) + srcdir=$ac_optarg ;; + + -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ + | --syscon | --sysco | --sysc | --sys | --sy) + ac_prev=sysconfdir ;; + -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ + | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) + sysconfdir=$ac_optarg ;; + + -target | --target | --targe | --targ | --tar | --ta | --t) + ac_prev=target_alias ;; + -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) + target_alias=$ac_optarg ;; + + -v | -verbose | --verbose | --verbos | --verbo | --verb) + verbose=yes ;; + + -version | --version | --versio | --versi | --vers | -V) + ac_init_version=: ;; + + -with-* | --with-*) + ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid package name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"with_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval with_$ac_useropt=\$ac_optarg ;; + + -without-* | --without-*) + ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid package name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"with_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval with_$ac_useropt=no ;; + + --x) + # Obsolete; use --with-x. + with_x=yes ;; + + -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ + | --x-incl | --x-inc | --x-in | --x-i) + ac_prev=x_includes ;; + -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ + | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) + x_includes=$ac_optarg ;; + + -x-libraries | --x-libraries | --x-librarie | --x-librari \ + | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) + ac_prev=x_libraries ;; + -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ + | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) + x_libraries=$ac_optarg ;; + + -*) as_fn_error $? "unrecognized option: \`$ac_option' +Try \`$0 --help' for more information" + ;; + + *=*) + ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` + # Reject names that are not valid shell variable names. + case $ac_envvar in #( + '' | [0-9]* | *[!_$as_cr_alnum]* ) + as_fn_error $? "invalid variable name: \`$ac_envvar'" ;; + esac + eval $ac_envvar=\$ac_optarg + export $ac_envvar ;; + + *) + # FIXME: should be removed in autoconf 3.0. + $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2 + expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && + $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2 + : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}" + ;; + + esac +done + +if test -n "$ac_prev"; then + ac_option=--`echo $ac_prev | sed 's/_/-/g'` + as_fn_error $? "missing argument to $ac_option" +fi + +if test -n "$ac_unrecognized_opts"; then + case $enable_option_checking in + no) ;; + fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; + *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; + esac +fi + +# Check all directory arguments for consistency. +for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ + datadir sysconfdir sharedstatedir localstatedir includedir \ + oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ + libdir localedir mandir +do + eval ac_val=\$$ac_var + # Remove trailing slashes. + case $ac_val in + */ ) + ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'` + eval $ac_var=\$ac_val;; + esac + # Be sure to have absolute directory names. + case $ac_val in + [\\/$]* | ?:[\\/]* ) continue;; + NONE | '' ) case $ac_var in *prefix ) continue;; esac;; + esac + as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val" +done + +# There might be people who depend on the old broken behavior: `$host' +# used to hold the argument of --host etc. +# FIXME: To remove some day. +build=$build_alias +host=$host_alias +target=$target_alias + +# FIXME: To remove some day. +if test "x$host_alias" != x; then + if test "x$build_alias" = x; then + cross_compiling=maybe + elif test "x$build_alias" != "x$host_alias"; then + cross_compiling=yes + fi +fi + +ac_tool_prefix= +test -n "$host_alias" && ac_tool_prefix=$host_alias- + +test "$silent" = yes && exec 6>/dev/null + + +ac_pwd=`pwd` && test -n "$ac_pwd" && +ac_ls_di=`ls -di .` && +ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || + as_fn_error $? "working directory cannot be determined" +test "X$ac_ls_di" = "X$ac_pwd_ls_di" || + as_fn_error $? "pwd does not report name of working directory" + + +# Find the source files, if location was not specified. +if test -z "$srcdir"; then + ac_srcdir_defaulted=yes + # Try the directory containing this script, then the parent directory. + ac_confdir=`$as_dirname -- "$as_myself" || +$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_myself" : 'X\(//\)[^/]' \| \ + X"$as_myself" : 'X\(//\)$' \| \ + X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_myself" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + srcdir=$ac_confdir + if test ! -r "$srcdir/$ac_unique_file"; then + srcdir=.. + fi +else + ac_srcdir_defaulted=no +fi +if test ! -r "$srcdir/$ac_unique_file"; then + test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." + as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir" +fi +ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" +ac_abs_confdir=`( + cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg" + pwd)` +# When building in place, set srcdir=. +if test "$ac_abs_confdir" = "$ac_pwd"; then + srcdir=. +fi +# Remove unnecessary trailing slashes from srcdir. +# Double slashes in file names in object file debugging info +# mess up M-x gdb in Emacs. +case $srcdir in +*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;; +esac +for ac_var in $ac_precious_vars; do + eval ac_env_${ac_var}_set=\${${ac_var}+set} + eval ac_env_${ac_var}_value=\$${ac_var} + eval ac_cv_env_${ac_var}_set=\${${ac_var}+set} + eval ac_cv_env_${ac_var}_value=\$${ac_var} +done + +# +# Report the --help message. +# +if test "$ac_init_help" = "long"; then + # Omit some internal or obsolete options to make the list less imposing. + # This message is too long to be a string in the A/UX 3.1 sh. + cat <<_ACEOF +\`configure' configures OpenFst 1.6.7 to adapt to many kinds of systems. + +Usage: $0 [OPTION]... [VAR=VALUE]... + +To assign environment variables (e.g., CC, CFLAGS...), specify them as +VAR=VALUE. See below for descriptions of some of the useful variables. + +Defaults for the options are specified in brackets. + +Configuration: + -h, --help display this help and exit + --help=short display options specific to this package + --help=recursive display the short help of all the included packages + -V, --version display version information and exit + -q, --quiet, --silent do not print \`checking ...' messages + --cache-file=FILE cache test results in FILE [disabled] + -C, --config-cache alias for \`--cache-file=config.cache' + -n, --no-create do not create output files + --srcdir=DIR find the sources in DIR [configure dir or \`..'] + +Installation directories: + --prefix=PREFIX install architecture-independent files in PREFIX + [$ac_default_prefix] + --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX + [PREFIX] + +By default, \`make install' will install all the files in +\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify +an installation prefix other than \`$ac_default_prefix' using \`--prefix', +for instance \`--prefix=\$HOME'. + +For better control, use the options below. + +Fine tuning of the installation directories: + --bindir=DIR user executables [EPREFIX/bin] + --sbindir=DIR system admin executables [EPREFIX/sbin] + --libexecdir=DIR program executables [EPREFIX/libexec] + --sysconfdir=DIR read-only single-machine data [PREFIX/etc] + --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] + --localstatedir=DIR modifiable single-machine data [PREFIX/var] + --libdir=DIR object code libraries [EPREFIX/lib] + --includedir=DIR C header files [PREFIX/include] + --oldincludedir=DIR C header files for non-gcc [/usr/include] + --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] + --datadir=DIR read-only architecture-independent data [DATAROOTDIR] + --infodir=DIR info documentation [DATAROOTDIR/info] + --localedir=DIR locale-dependent data [DATAROOTDIR/locale] + --mandir=DIR man documentation [DATAROOTDIR/man] + --docdir=DIR documentation root [DATAROOTDIR/doc/openfst] + --htmldir=DIR html documentation [DOCDIR] + --dvidir=DIR dvi documentation [DOCDIR] + --pdfdir=DIR pdf documentation [DOCDIR] + --psdir=DIR ps documentation [DOCDIR] +_ACEOF + + cat <<\_ACEOF + +Program names: + --program-prefix=PREFIX prepend PREFIX to installed program names + --program-suffix=SUFFIX append SUFFIX to installed program names + --program-transform-name=PROGRAM run sed PROGRAM on installed program names + +System types: + --build=BUILD configure for building on BUILD [guessed] + --host=HOST cross-compile to build programs to run on HOST [BUILD] +_ACEOF +fi + +if test -n "$ac_init_help"; then + case $ac_init_help in + short | recursive ) echo "Configuration of OpenFst 1.6.7:";; + esac + cat <<\_ACEOF + +Optional Features: + --disable-option-checking ignore unrecognized --enable/--with options + --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) + --enable-FEATURE[=ARG] include FEATURE [ARG=yes] + --enable-silent-rules less verbose build output (undo: "make V=1") + --disable-silent-rules verbose build output (undo: "make V=0") + --enable-dependency-tracking + do not reject slow dependency extractors + --disable-dependency-tracking + speeds up one-time build + --enable-static[=PKGS] build static libraries [default=no] + --enable-shared[=PKGS] build shared libraries [default=yes] + --enable-fast-install[=PKGS] + optimize for fast installation [default=yes] + --disable-libtool-lock avoid locking (might break parallel builds) + --enable-compact-fsts enable CompactFst extensions + --enable-compress enable compression extension + --enable-const-fsts enable ConstFst extensions + --enable-far enable FAR extensions + --enable-linear-fsts enable LinearTagger/ClassifierFst extensions + --enable-lookahead-fsts enable LookAheadFst extensions + --enable-mpdt enable MPDT extensions + --enable-ngram-fsts enable NGramFst extension + --enable-pdt enable PDT extensions + --enable-python enable Python extensions + --enable-special enable special-matcher extensions + --enable-bin enable fst::script and command-line binaries + --enable-grm enable all dependencies of OpenGrm + +Optional Packages: + --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] + --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) + --with-pic[=PKGS] try to use only PIC/non-PIC objects [default=use + both] + --with-gnu-ld assume the C compiler uses GNU ld [default=no] + --with-sysroot=DIR Search for dependent libraries within DIR + (or the compiler's sysroot if not specified). +--with-libfstdir=DIR fst dynamic extensions [LIBDIR/fst] + +Some influential environment variables: + CC C compiler command + CFLAGS C compiler flags + LDFLAGS linker flags, e.g. -L if you have libraries in a + nonstandard directory + LIBS libraries to pass to the linker, e.g. -l + CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I if + you have headers in a nonstandard directory + CXX C++ compiler command + CXXFLAGS C++ compiler flags + CPP C preprocessor + CXXCPP C++ preprocessor + PYTHON the Python interpreter + PYTHON_VERSION + The installed Python version to use, for example '2.3'. This + string will be appended to the Python interpreter canonical + name. + +Use these variables to override the choices made by `configure' or to help +it to find libraries and programs with nonstandard names/locations. + +Report bugs to . +_ACEOF +ac_status=$? +fi + +if test "$ac_init_help" = "recursive"; then + # If there are subdirs, report their specific --help. + for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue + test -d "$ac_dir" || + { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } || + continue + ac_builddir=. + +case "$ac_dir" in +.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; +*) + ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` + # A ".." for each directory in $ac_dir_suffix. + ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` + case $ac_top_builddir_sub in + "") ac_top_builddir_sub=. ac_top_build_prefix= ;; + *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; + esac ;; +esac +ac_abs_top_builddir=$ac_pwd +ac_abs_builddir=$ac_pwd$ac_dir_suffix +# for backward compatibility: +ac_top_builddir=$ac_top_build_prefix + +case $srcdir in + .) # We are building in place. + ac_srcdir=. + ac_top_srcdir=$ac_top_builddir_sub + ac_abs_top_srcdir=$ac_pwd ;; + [\\/]* | ?:[\\/]* ) # Absolute name. + ac_srcdir=$srcdir$ac_dir_suffix; + ac_top_srcdir=$srcdir + ac_abs_top_srcdir=$srcdir ;; + *) # Relative name. + ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix + ac_top_srcdir=$ac_top_build_prefix$srcdir + ac_abs_top_srcdir=$ac_pwd/$srcdir ;; +esac +ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix + + cd "$ac_dir" || { ac_status=$?; continue; } + # Check for guested configure. + if test -f "$ac_srcdir/configure.gnu"; then + echo && + $SHELL "$ac_srcdir/configure.gnu" --help=recursive + elif test -f "$ac_srcdir/configure"; then + echo && + $SHELL "$ac_srcdir/configure" --help=recursive + else + $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 + fi || ac_status=$? + cd "$ac_pwd" || { ac_status=$?; break; } + done +fi + +test -n "$ac_init_help" && exit $ac_status +if $ac_init_version; then + cat <<\_ACEOF +OpenFst configure 1.6.7 +generated by GNU Autoconf 2.69 + +Copyright (C) 2012 Free Software Foundation, Inc. +This configure script is free software; the Free Software Foundation +gives unlimited permission to copy, distribute and modify it. +_ACEOF + exit +fi + +## ------------------------ ## +## Autoconf initialization. ## +## ------------------------ ## + +# ac_fn_c_try_compile LINENO +# -------------------------- +# Try to compile conftest.$ac_ext, and return whether this succeeded. +ac_fn_c_try_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext + if { { ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_c_try_compile + +# ac_fn_cxx_try_compile LINENO +# ---------------------------- +# Try to compile conftest.$ac_ext, and return whether this succeeded. +ac_fn_cxx_try_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext + if { { ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_cxx_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_cxx_try_compile + +# ac_fn_c_try_link LINENO +# ----------------------- +# Try to link conftest.$ac_ext, and return whether this succeeded. +ac_fn_c_try_link () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext conftest$ac_exeext + if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest$ac_exeext && { + test "$cross_compiling" = yes || + test -x conftest$ac_exeext + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information + # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would + # interfere with the next link command; also delete a directory that is + # left behind by Apple's compiler. We do this before executing the actions. + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_c_try_link + +# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES +# ------------------------------------------------------- +# Tests whether HEADER exists and can be compiled using the include files in +# INCLUDES, setting the cache variable VAR accordingly. +ac_fn_c_check_header_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$4 +#include <$2> +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + eval "$3=yes" +else + eval "$3=no" +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} # ac_fn_c_check_header_compile + +# ac_fn_c_try_cpp LINENO +# ---------------------- +# Try to preprocess conftest.$ac_ext, and return whether this succeeded. +ac_fn_c_try_cpp () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_cpp conftest.$ac_ext" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } > conftest.i && { + test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || + test ! -s conftest.err + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_c_try_cpp + +# ac_fn_c_try_run LINENO +# ---------------------- +# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes +# that executables *can* be run. +ac_fn_c_try_run () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' + { { case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_try") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; }; then : + ac_retval=0 +else + $as_echo "$as_me: program exited with status $ac_status" >&5 + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=$ac_status +fi + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_c_try_run + +# ac_fn_c_check_func LINENO FUNC VAR +# ---------------------------------- +# Tests whether FUNC exists, setting the cache variable VAR accordingly +ac_fn_c_check_func () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +/* Define $2 to an innocuous variant, in case declares $2. + For example, HP-UX 11i declares gettimeofday. */ +#define $2 innocuous_$2 + +/* System header to define __stub macros and hopefully few prototypes, + which can conflict with char $2 (); below. + Prefer to if __STDC__ is defined, since + exists even on freestanding compilers. */ + +#ifdef __STDC__ +# include +#else +# include +#endif + +#undef $2 + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char $2 (); +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined __stub_$2 || defined __stub___$2 +choke me +#endif + +int +main () +{ +return $2 (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + eval "$3=yes" +else + eval "$3=no" +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} # ac_fn_c_check_func + +# ac_fn_cxx_try_cpp LINENO +# ------------------------ +# Try to preprocess conftest.$ac_ext, and return whether this succeeded. +ac_fn_cxx_try_cpp () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_cpp conftest.$ac_ext" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } > conftest.i && { + test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" || + test ! -s conftest.err + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_cxx_try_cpp + +# ac_fn_cxx_try_link LINENO +# ------------------------- +# Try to link conftest.$ac_ext, and return whether this succeeded. +ac_fn_cxx_try_link () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext conftest$ac_exeext + if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_cxx_werror_flag" || + test ! -s conftest.err + } && test -s conftest$ac_exeext && { + test "$cross_compiling" = yes || + test -x conftest$ac_exeext + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information + # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would + # interfere with the next link command; also delete a directory that is + # left behind by Apple's compiler. We do this before executing the actions. + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_cxx_try_link +cat >config.log <<_ACEOF +This file contains any messages produced by compilers while +running configure, to aid debugging if configure makes a mistake. + +It was created by OpenFst $as_me 1.6.7, which was +generated by GNU Autoconf 2.69. Invocation command line was + + $ $0 $@ + +_ACEOF +exec 5>>config.log +{ +cat <<_ASUNAME +## --------- ## +## Platform. ## +## --------- ## + +hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` +uname -m = `(uname -m) 2>/dev/null || echo unknown` +uname -r = `(uname -r) 2>/dev/null || echo unknown` +uname -s = `(uname -s) 2>/dev/null || echo unknown` +uname -v = `(uname -v) 2>/dev/null || echo unknown` + +/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` +/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` + +/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` +/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` +/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` +/usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` +/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` +/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` +/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` + +_ASUNAME + +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + $as_echo "PATH: $as_dir" + done +IFS=$as_save_IFS + +} >&5 + +cat >&5 <<_ACEOF + + +## ----------- ## +## Core tests. ## +## ----------- ## + +_ACEOF + + +# Keep a trace of the command line. +# Strip out --no-create and --no-recursion so they do not pile up. +# Strip out --silent because we don't want to record it for future runs. +# Also quote any args containing shell meta-characters. +# Make two passes to allow for proper duplicate-argument suppression. +ac_configure_args= +ac_configure_args0= +ac_configure_args1= +ac_must_keep_next=false +for ac_pass in 1 2 +do + for ac_arg + do + case $ac_arg in + -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + continue ;; + *\'*) + ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + case $ac_pass in + 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; + 2) + as_fn_append ac_configure_args1 " '$ac_arg'" + if test $ac_must_keep_next = true; then + ac_must_keep_next=false # Got value, back to normal. + else + case $ac_arg in + *=* | --config-cache | -C | -disable-* | --disable-* \ + | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ + | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ + | -with-* | --with-* | -without-* | --without-* | --x) + case "$ac_configure_args0 " in + "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; + esac + ;; + -* ) ac_must_keep_next=true ;; + esac + fi + as_fn_append ac_configure_args " '$ac_arg'" + ;; + esac + done +done +{ ac_configure_args0=; unset ac_configure_args0;} +{ ac_configure_args1=; unset ac_configure_args1;} + +# When interrupted or exit'd, cleanup temporary files, and complete +# config.log. We remove comments because anyway the quotes in there +# would cause problems or look ugly. +# WARNING: Use '\'' to represent an apostrophe within the trap. +# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. +trap 'exit_status=$? + # Save into config.log some information that might help in debugging. + { + echo + + $as_echo "## ---------------- ## +## Cache variables. ## +## ---------------- ##" + echo + # The following way of writing the cache mishandles newlines in values, +( + for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do + eval ac_val=\$$ac_var + case $ac_val in #( + *${as_nl}*) + case $ac_var in #( + *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 +$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; + esac + case $ac_var in #( + _ | IFS | as_nl) ;; #( + BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( + *) { eval $ac_var=; unset $ac_var;} ;; + esac ;; + esac + done + (set) 2>&1 | + case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #( + *${as_nl}ac_space=\ *) + sed -n \ + "s/'\''/'\''\\\\'\'''\''/g; + s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" + ;; #( + *) + sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" + ;; + esac | + sort +) + echo + + $as_echo "## ----------------- ## +## Output variables. ## +## ----------------- ##" + echo + for ac_var in $ac_subst_vars + do + eval ac_val=\$$ac_var + case $ac_val in + *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + esac + $as_echo "$ac_var='\''$ac_val'\''" + done | sort + echo + + if test -n "$ac_subst_files"; then + $as_echo "## ------------------- ## +## File substitutions. ## +## ------------------- ##" + echo + for ac_var in $ac_subst_files + do + eval ac_val=\$$ac_var + case $ac_val in + *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + esac + $as_echo "$ac_var='\''$ac_val'\''" + done | sort + echo + fi + + if test -s confdefs.h; then + $as_echo "## ----------- ## +## confdefs.h. ## +## ----------- ##" + echo + cat confdefs.h + echo + fi + test "$ac_signal" != 0 && + $as_echo "$as_me: caught signal $ac_signal" + $as_echo "$as_me: exit $exit_status" + } >&5 + rm -f core *.core core.conftest.* && + rm -f -r conftest* confdefs* conf$$* $ac_clean_files && + exit $exit_status +' 0 +for ac_signal in 1 2 13 15; do + trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal +done +ac_signal=0 + +# confdefs.h avoids OS command line length limits that DEFS can exceed. +rm -f -r conftest* confdefs.h + +$as_echo "/* confdefs.h */" > confdefs.h + +# Predefined preprocessor variables. + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_NAME "$PACKAGE_NAME" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_TARNAME "$PACKAGE_TARNAME" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_VERSION "$PACKAGE_VERSION" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_STRING "$PACKAGE_STRING" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_URL "$PACKAGE_URL" +_ACEOF + + +# Let the site file select an alternate cache file if it wants to. +# Prefer an explicitly selected file to automatically selected ones. +ac_site_file1=NONE +ac_site_file2=NONE +if test -n "$CONFIG_SITE"; then + # We do not want a PATH search for config.site. + case $CONFIG_SITE in #(( + -*) ac_site_file1=./$CONFIG_SITE;; + */*) ac_site_file1=$CONFIG_SITE;; + *) ac_site_file1=./$CONFIG_SITE;; + esac +elif test "x$prefix" != xNONE; then + ac_site_file1=$prefix/share/config.site + ac_site_file2=$prefix/etc/config.site +else + ac_site_file1=$ac_default_prefix/share/config.site + ac_site_file2=$ac_default_prefix/etc/config.site +fi +for ac_site_file in "$ac_site_file1" "$ac_site_file2" +do + test "x$ac_site_file" = xNONE && continue + if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 +$as_echo "$as_me: loading site script $ac_site_file" >&6;} + sed 's/^/| /' "$ac_site_file" >&5 + . "$ac_site_file" \ + || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "failed to load site script $ac_site_file +See \`config.log' for more details" "$LINENO" 5; } + fi +done + +if test -r "$cache_file"; then + # Some versions of bash will fail to source /dev/null (special files + # actually), so we avoid doing that. DJGPP emulates it as a regular file. + if test /dev/null != "$cache_file" && test -f "$cache_file"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 +$as_echo "$as_me: loading cache $cache_file" >&6;} + case $cache_file in + [\\/]* | ?:[\\/]* ) . "$cache_file";; + *) . "./$cache_file";; + esac + fi +else + { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 +$as_echo "$as_me: creating cache $cache_file" >&6;} + >$cache_file +fi + +# Check that the precious variables saved in the cache have kept the same +# value. +ac_cache_corrupted=false +for ac_var in $ac_precious_vars; do + eval ac_old_set=\$ac_cv_env_${ac_var}_set + eval ac_new_set=\$ac_env_${ac_var}_set + eval ac_old_val=\$ac_cv_env_${ac_var}_value + eval ac_new_val=\$ac_env_${ac_var}_value + case $ac_old_set,$ac_new_set in + set,) + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 +$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} + ac_cache_corrupted=: ;; + ,set) + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 +$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} + ac_cache_corrupted=: ;; + ,);; + *) + if test "x$ac_old_val" != "x$ac_new_val"; then + # differences in whitespace do not lead to failure. + ac_old_val_w=`echo x $ac_old_val` + ac_new_val_w=`echo x $ac_new_val` + if test "$ac_old_val_w" != "$ac_new_val_w"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 +$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} + ac_cache_corrupted=: + else + { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 +$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} + eval $ac_var=\$ac_old_val + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 +$as_echo "$as_me: former value: \`$ac_old_val'" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 +$as_echo "$as_me: current value: \`$ac_new_val'" >&2;} + fi;; + esac + # Pass precious variables to config.status. + if test "$ac_new_set" = set; then + case $ac_new_val in + *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; + *) ac_arg=$ac_var=$ac_new_val ;; + esac + case " $ac_configure_args " in + *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. + *) as_fn_append ac_configure_args " '$ac_arg'" ;; + esac + fi +done +if $ac_cache_corrupted; then + { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 +$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;} + as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5 +fi +## -------------------- ## +## Main body of script. ## +## -------------------- ## + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + +am__api_version='1.14' + +ac_aux_dir= +for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do + if test -f "$ac_dir/install-sh"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install-sh -c" + break + elif test -f "$ac_dir/install.sh"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install.sh -c" + break + elif test -f "$ac_dir/shtool"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/shtool install -c" + break + fi +done +if test -z "$ac_aux_dir"; then + as_fn_error $? "cannot find install-sh, install.sh, or shtool in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" "$LINENO" 5 +fi + +# These three variables are undocumented and unsupported, +# and are intended to be withdrawn in a future Autoconf release. +# They can cause serious problems if a builder's source tree is in a directory +# whose full name contains unusual characters. +ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var. +ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var. +ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var. + + +# Find a good install program. We prefer a C program (faster), +# so one script is as good as another. But avoid the broken or +# incompatible versions: +# SysV /etc/install, /usr/sbin/install +# SunOS /usr/etc/install +# IRIX /sbin/install +# AIX /bin/install +# AmigaOS /C/install, which installs bootblocks on floppy discs +# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag +# AFS /usr/afsws/bin/install, which mishandles nonexistent args +# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" +# OS/2's system install, which has a completely different semantic +# ./install, which can be erroneously created by make from ./install.sh. +# Reject install programs that cannot install multiple files. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5 +$as_echo_n "checking for a BSD-compatible install... " >&6; } +if test -z "$INSTALL"; then +if ${ac_cv_path_install+:} false; then : + $as_echo_n "(cached) " >&6 +else + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + # Account for people who put trailing slashes in PATH elements. +case $as_dir/ in #(( + ./ | .// | /[cC]/* | \ + /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \ + ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \ + /usr/ucb/* ) ;; + *) + # OSF1 and SCO ODT 3.0 have their own names for install. + # Don't use installbsd from OSF since it installs stuff as root + # by default. + for ac_prog in ginstall scoinst install; do + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then + if test $ac_prog = install && + grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then + # AIX install. It has an incompatible calling convention. + : + elif test $ac_prog = install && + grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then + # program-specific install script used by HP pwplus--don't use. + : + else + rm -rf conftest.one conftest.two conftest.dir + echo one > conftest.one + echo two > conftest.two + mkdir conftest.dir + if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" && + test -s conftest.one && test -s conftest.two && + test -s conftest.dir/conftest.one && + test -s conftest.dir/conftest.two + then + ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c" + break 3 + fi + fi + fi + done + done + ;; +esac + + done +IFS=$as_save_IFS + +rm -rf conftest.one conftest.two conftest.dir + +fi + if test "${ac_cv_path_install+set}" = set; then + INSTALL=$ac_cv_path_install + else + # As a last resort, use the slow shell script. Don't cache a + # value for INSTALL within a source directory, because that will + # break other packages using the cache if that directory is + # removed, or if the value is a relative name. + INSTALL=$ac_install_sh + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5 +$as_echo "$INSTALL" >&6; } + +# Use test -z because SunOS4 sh mishandles braces in ${var-val}. +# It thinks the first close brace ends the variable substitution. +test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' + +test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}' + +test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5 +$as_echo_n "checking whether build environment is sane... " >&6; } +# Reject unsafe characters in $srcdir or the absolute working directory +# name. Accept space and tab only in the latter. +am_lf=' +' +case `pwd` in + *[\\\"\#\$\&\'\`$am_lf]*) + as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5;; +esac +case $srcdir in + *[\\\"\#\$\&\'\`$am_lf\ \ ]*) + as_fn_error $? "unsafe srcdir value: '$srcdir'" "$LINENO" 5;; +esac + +# Do 'set' in a subshell so we don't clobber the current shell's +# arguments. Must try -L first in case configure is actually a +# symlink; some systems play weird games with the mod time of symlinks +# (eg FreeBSD returns the mod time of the symlink's containing +# directory). +if ( + am_has_slept=no + for am_try in 1 2; do + echo "timestamp, slept: $am_has_slept" > conftest.file + set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null` + if test "$*" = "X"; then + # -L didn't work. + set X `ls -t "$srcdir/configure" conftest.file` + fi + if test "$*" != "X $srcdir/configure conftest.file" \ + && test "$*" != "X conftest.file $srcdir/configure"; then + + # If neither matched, then we have a broken ls. This can happen + # if, for instance, CONFIG_SHELL is bash and it inherits a + # broken ls alias from the environment. This has actually + # happened. Such a system could not be considered "sane". + as_fn_error $? "ls -t appears to fail. Make sure there is not a broken + alias in your environment" "$LINENO" 5 + fi + if test "$2" = conftest.file || test $am_try -eq 2; then + break + fi + # Just in case. + sleep 1 + am_has_slept=yes + done + test "$2" = conftest.file + ) +then + # Ok. + : +else + as_fn_error $? "newly created file is older than distributed files! +Check your system clock" "$LINENO" 5 +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +# If we didn't sleep, we still need to ensure time stamps of config.status and +# generated files are strictly newer. +am_sleep_pid= +if grep 'slept: no' conftest.file >/dev/null 2>&1; then + ( sleep 1 ) & + am_sleep_pid=$! +fi + +rm -f conftest.file + +test "$program_prefix" != NONE && + program_transform_name="s&^&$program_prefix&;$program_transform_name" +# Use a double $ so make ignores it. +test "$program_suffix" != NONE && + program_transform_name="s&\$&$program_suffix&;$program_transform_name" +# Double any \ or $. +# By default was `s,x,x', remove it if useless. +ac_script='s/[\\$]/&&/g;s/;s,x,x,$//' +program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"` + +# expand $ac_aux_dir to an absolute path +am_aux_dir=`cd $ac_aux_dir && pwd` + +if test x"${MISSING+set}" != xset; then + case $am_aux_dir in + *\ * | *\ *) + MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;; + *) + MISSING="\${SHELL} $am_aux_dir/missing" ;; + esac +fi +# Use eval to expand $SHELL +if eval "$MISSING --is-lightweight"; then + am_missing_run="$MISSING " +else + am_missing_run= + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5 +$as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;} +fi + +if test x"${install_sh}" != xset; then + case $am_aux_dir in + *\ * | *\ *) + install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;; + *) + install_sh="\${SHELL} $am_aux_dir/install-sh" + esac +fi + +# Installed binaries are usually stripped using 'strip' when the user +# run "make install-strip". However 'strip' might not be the right +# tool to use in cross-compilation environments, therefore Automake +# will honor the 'STRIP' environment variable to overrule this program. +if test "$cross_compiling" != no; then + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. +set dummy ${ac_tool_prefix}strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_STRIP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$STRIP"; then + ac_cv_prog_STRIP="$STRIP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_STRIP="${ac_tool_prefix}strip" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +STRIP=$ac_cv_prog_STRIP +if test -n "$STRIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 +$as_echo "$STRIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_STRIP"; then + ac_ct_STRIP=$STRIP + # Extract the first word of "strip", so it can be a program name with args. +set dummy strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_STRIP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_STRIP"; then + ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_STRIP="strip" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP +if test -n "$ac_ct_STRIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 +$as_echo "$ac_ct_STRIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_STRIP" = x; then + STRIP=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + STRIP=$ac_ct_STRIP + fi +else + STRIP="$ac_cv_prog_STRIP" +fi + +fi +INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s" + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a thread-safe mkdir -p" >&5 +$as_echo_n "checking for a thread-safe mkdir -p... " >&6; } +if test -z "$MKDIR_P"; then + if ${ac_cv_path_mkdir+:} false; then : + $as_echo_n "(cached) " >&6 +else + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in mkdir gmkdir; do + for ac_exec_ext in '' $ac_executable_extensions; do + as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext" || continue + case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #( + 'mkdir (GNU coreutils) '* | \ + 'mkdir (coreutils) '* | \ + 'mkdir (fileutils) '4.1*) + ac_cv_path_mkdir=$as_dir/$ac_prog$ac_exec_ext + break 3;; + esac + done + done + done +IFS=$as_save_IFS + +fi + + test -d ./--version && rmdir ./--version + if test "${ac_cv_path_mkdir+set}" = set; then + MKDIR_P="$ac_cv_path_mkdir -p" + else + # As a last resort, use the slow shell script. Don't cache a + # value for MKDIR_P within a source directory, because that will + # break other packages using the cache if that directory is + # removed, or if the value is a relative name. + MKDIR_P="$ac_install_sh -d" + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5 +$as_echo "$MKDIR_P" >&6; } + +for ac_prog in gawk mawk nawk awk +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_AWK+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$AWK"; then + ac_cv_prog_AWK="$AWK" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_AWK="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +AWK=$ac_cv_prog_AWK +if test -n "$AWK"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 +$as_echo "$AWK" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$AWK" && break +done + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5 +$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; } +set x ${MAKE-make} +ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'` +if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat >conftest.make <<\_ACEOF +SHELL = /bin/sh +all: + @echo '@@@%%%=$(MAKE)=@@@%%%' +_ACEOF +# GNU make sometimes prints "make[1]: Entering ...", which would confuse us. +case `${MAKE-make} -f conftest.make 2>/dev/null` in + *@@@%%%=?*=@@@%%%*) + eval ac_cv_prog_make_${ac_make}_set=yes;; + *) + eval ac_cv_prog_make_${ac_make}_set=no;; +esac +rm -f conftest.make +fi +if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + SET_MAKE= +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + SET_MAKE="MAKE=${MAKE-make}" +fi + +rm -rf .tst 2>/dev/null +mkdir .tst 2>/dev/null +if test -d .tst; then + am__leading_dot=. +else + am__leading_dot=_ +fi +rmdir .tst 2>/dev/null + +# Check whether --enable-silent-rules was given. +if test "${enable_silent_rules+set}" = set; then : + enableval=$enable_silent_rules; +fi + +case $enable_silent_rules in # ((( + yes) AM_DEFAULT_VERBOSITY=0;; + no) AM_DEFAULT_VERBOSITY=1;; + *) AM_DEFAULT_VERBOSITY=1;; +esac +am_make=${MAKE-make} +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5 +$as_echo_n "checking whether $am_make supports nested variables... " >&6; } +if ${am_cv_make_support_nested_variables+:} false; then : + $as_echo_n "(cached) " >&6 +else + if $as_echo 'TRUE=$(BAR$(V)) +BAR0=false +BAR1=true +V=1 +am__doit: + @$(TRUE) +.PHONY: am__doit' | $am_make -f - >/dev/null 2>&1; then + am_cv_make_support_nested_variables=yes +else + am_cv_make_support_nested_variables=no +fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5 +$as_echo "$am_cv_make_support_nested_variables" >&6; } +if test $am_cv_make_support_nested_variables = yes; then + AM_V='$(V)' + AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)' +else + AM_V=$AM_DEFAULT_VERBOSITY + AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY +fi +AM_BACKSLASH='\' + +if test "`cd $srcdir && pwd`" != "`pwd`"; then + # Use -I$(srcdir) only when $(srcdir) != ., so that make's output + # is not polluted with repeated "-I." + am__isrc=' -I$(srcdir)' + # test to see if srcdir already configured + if test -f $srcdir/config.status; then + as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5 + fi +fi + +# test whether we have cygpath +if test -z "$CYGPATH_W"; then + if (cygpath --version) >/dev/null 2>/dev/null; then + CYGPATH_W='cygpath -w' + else + CYGPATH_W=echo + fi +fi + + +# Define the identity of the package. + PACKAGE='openfst' + VERSION='1.6.7' + + +cat >>confdefs.h <<_ACEOF +#define PACKAGE "$PACKAGE" +_ACEOF + + +cat >>confdefs.h <<_ACEOF +#define VERSION "$VERSION" +_ACEOF + +# Some tools Automake needs. + +ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"} + + +AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"} + + +AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"} + + +AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"} + + +MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"} + +# For better backward compatibility. To be removed once Automake 1.9.x +# dies out for good. For more background, see: +# +# +mkdir_p='$(MKDIR_P)' + +# We need awk for the "check" target. The system "awk" is bad on +# some platforms. +# Always define AMTAR for backward compatibility. Yes, it's still used +# in the wild :-( We should find a proper way to deprecate it ... +AMTAR='$${TAR-tar}' + + +# We'll loop over all known methods to create a tar archive until one works. +_am_tools='gnutar pax cpio none' + +am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -' + + + + + + +# POSIX will say in a future version that running "rm -f" with no argument +# is OK; and we want to be able to make that assumption in our Makefile +# recipes. So use an aggressive probe to check that the usage we want is +# actually supported "in the wild" to an acceptable degree. +# See automake bug#10828. +# To make any issue more visible, cause the running configure to be aborted +# by default if the 'rm' program in use doesn't match our expectations; the +# user can still override this though. +if rm -f && rm -fr && rm -rf; then : OK; else + cat >&2 <<'END' +Oops! + +Your 'rm' program seems unable to run without file operands specified +on the command line, even when the '-f' option is present. This is contrary +to the behaviour of most rm programs out there, and not conforming with +the upcoming POSIX standard: + +Please tell bug-automake@gnu.org about your system, including the value +of your $PATH and any error possibly output before this message. This +can help us improve future automake versions. + +END + if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then + echo 'Configuration will proceed anyway, since you have set the' >&2 + echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2 + echo >&2 + else + cat >&2 <<'END' +Aborting the configuration process, to ensure you take notice of the issue. + +You can download and install GNU coreutils to get an 'rm' implementation +that behaves properly: . + +If you want to complete the configuration process using your problematic +'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM +to "yes", and re-run configure. + +END + as_fn_error $? "Your 'rm' program is bad, sorry." "$LINENO" 5 + fi +fi +DEPDIR="${am__leading_dot}deps" + +ac_config_commands="$ac_config_commands depfiles" + + +am_make=${MAKE-make} +cat > confinc << 'END' +am__doit: + @echo this is the am__doit target +.PHONY: am__doit +END +# If we don't find an include directive, just comment out the code. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5 +$as_echo_n "checking for style of include used by $am_make... " >&6; } +am__include="#" +am__quote= +_am_result=none +# First try GNU make style include. +echo "include confinc" > confmf +# Ignore all kinds of additional output from 'make'. +case `$am_make -s -f confmf 2> /dev/null` in #( +*the\ am__doit\ target*) + am__include=include + am__quote= + _am_result=GNU + ;; +esac +# Now try BSD make style include. +if test "$am__include" = "#"; then + echo '.include "confinc"' > confmf + case `$am_make -s -f confmf 2> /dev/null` in #( + *the\ am__doit\ target*) + am__include=.include + am__quote="\"" + _am_result=BSD + ;; + esac +fi + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5 +$as_echo "$_am_result" >&6; } +rm -f confinc confmf + +# Check whether --enable-dependency-tracking was given. +if test "${enable_dependency_tracking+set}" = set; then : + enableval=$enable_dependency_tracking; +fi + +if test "x$enable_dependency_tracking" != xno; then + am_depcomp="$ac_aux_dir/depcomp" + AMDEPBACKSLASH='\' + am__nodep='_no' +fi + if test "x$enable_dependency_tracking" != xno; then + AMDEP_TRUE= + AMDEP_FALSE='#' +else + AMDEP_TRUE='#' + AMDEP_FALSE= +fi + + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. +set dummy ${ac_tool_prefix}gcc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="${ac_tool_prefix}gcc" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +$as_echo "$CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_CC"; then + ac_ct_CC=$CC + # Extract the first word of "gcc", so it can be a program name with args. +set dummy gcc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_CC"; then + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CC="gcc" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_CC=$ac_cv_prog_ac_ct_CC +if test -n "$ac_ct_CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 +$as_echo "$ac_ct_CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_CC" = x; then + CC="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + CC=$ac_ct_CC + fi +else + CC="$ac_cv_prog_CC" +fi + +if test -z "$CC"; then + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. +set dummy ${ac_tool_prefix}cc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="${ac_tool_prefix}cc" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +$as_echo "$CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + fi +fi +if test -z "$CC"; then + # Extract the first word of "cc", so it can be a program name with args. +set dummy cc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else + ac_prog_rejected=no +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then + ac_prog_rejected=yes + continue + fi + ac_cv_prog_CC="cc" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +if test $ac_prog_rejected = yes; then + # We found a bogon in the path, so make sure we never use it. + set dummy $ac_cv_prog_CC + shift + if test $# != 0; then + # We chose a different compiler from the bogus one. + # However, it has the same basename, so the bogon will be chosen + # first if we set CC to just the basename; use the full file name. + shift + ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@" + fi +fi +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +$as_echo "$CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$CC"; then + if test -n "$ac_tool_prefix"; then + for ac_prog in cl.exe + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +$as_echo "$CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$CC" && break + done +fi +if test -z "$CC"; then + ac_ct_CC=$CC + for ac_prog in cl.exe +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_CC"; then + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CC="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_CC=$ac_cv_prog_ac_ct_CC +if test -n "$ac_ct_CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 +$as_echo "$ac_ct_CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_CC" && break +done + + if test "x$ac_ct_CC" = x; then + CC="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + CC=$ac_ct_CC + fi +fi + +fi + + +test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "no acceptable C compiler found in \$PATH +See \`config.log' for more details" "$LINENO" 5; } + +# Provide some information about the compiler. +$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 +set X $ac_compile +ac_compiler=$2 +for ac_option in --version -v -V -qversion; do + { { ac_try="$ac_compiler $ac_option >&5" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compiler $ac_option >&5") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + sed '10a\ +... rest of stderr output deleted ... + 10q' conftest.err >conftest.er1 + cat conftest.er1 >&5 + fi + rm -f conftest.er1 conftest.err + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } +done + +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +ac_clean_files_save=$ac_clean_files +ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out" +# Try to create an executable without -o first, disregard a.out. +# It will help us diagnose broken compilers, and finding out an intuition +# of exeext. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 +$as_echo_n "checking whether the C compiler works... " >&6; } +ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` + +# The possible output files: +ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" + +ac_rmfiles= +for ac_file in $ac_files +do + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; + * ) ac_rmfiles="$ac_rmfiles $ac_file";; + esac +done +rm -f $ac_rmfiles + +if { { ac_try="$ac_link_default" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link_default") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then : + # Autoconf-2.13 could set the ac_cv_exeext variable to `no'. +# So ignore a value of `no', otherwise this would lead to `EXEEXT = no' +# in a Makefile. We should not override ac_cv_exeext if it was cached, +# so that the user can short-circuit this test for compilers unknown to +# Autoconf. +for ac_file in $ac_files '' +do + test -f "$ac_file" || continue + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) + ;; + [ab].out ) + # We found the default executable, but exeext='' is most + # certainly right. + break;; + *.* ) + if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no; + then :; else + ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` + fi + # We set ac_cv_exeext here because the later test for it is not + # safe: cross compilers may not add the suffix if given an `-o' + # argument, so we may need to know it at that point already. + # Even if this section looks crufty: it has the advantage of + # actually working. + break;; + * ) + break;; + esac +done +test "$ac_cv_exeext" = no && ac_cv_exeext= + +else + ac_file='' +fi +if test -z "$ac_file"; then : + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +$as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error 77 "C compiler cannot create executables +See \`config.log' for more details" "$LINENO" 5; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 +$as_echo_n "checking for C compiler default output file name... " >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 +$as_echo "$ac_file" >&6; } +ac_exeext=$ac_cv_exeext + +rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out +ac_clean_files=$ac_clean_files_save +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 +$as_echo_n "checking for suffix of executables... " >&6; } +if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then : + # If both `conftest.exe' and `conftest' are `present' (well, observable) +# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will +# work properly (i.e., refer to `conftest.exe'), while it won't with +# `rm'. +for ac_file in conftest.exe conftest conftest.*; do + test -f "$ac_file" || continue + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; + *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` + break;; + * ) break;; + esac +done +else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "cannot compute suffix of executables: cannot compile and link +See \`config.log' for more details" "$LINENO" 5; } +fi +rm -f conftest conftest$ac_cv_exeext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 +$as_echo "$ac_cv_exeext" >&6; } + +rm -f conftest.$ac_ext +EXEEXT=$ac_cv_exeext +ac_exeext=$EXEEXT +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +int +main () +{ +FILE *f = fopen ("conftest.out", "w"); + return ferror (f) || fclose (f) != 0; + + ; + return 0; +} +_ACEOF +ac_clean_files="$ac_clean_files conftest.out" +# Check that the compiler produces executables we can run. If not, either +# the compiler is broken, or we cross compile. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 +$as_echo_n "checking whether we are cross compiling... " >&6; } +if test "$cross_compiling" != yes; then + { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + if { ac_try='./conftest$ac_cv_exeext' + { { case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_try") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; }; then + cross_compiling=no + else + if test "$cross_compiling" = maybe; then + cross_compiling=yes + else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "cannot run C compiled programs. +If you meant to cross compile, use \`--host'. +See \`config.log' for more details" "$LINENO" 5; } + fi + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 +$as_echo "$cross_compiling" >&6; } + +rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out +ac_clean_files=$ac_clean_files_save +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 +$as_echo_n "checking for suffix of object files... " >&6; } +if ${ac_cv_objext+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +rm -f conftest.o conftest.obj +if { { ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then : + for ac_file in conftest.o conftest.obj conftest.*; do + test -f "$ac_file" || continue; + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;; + *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` + break;; + esac +done +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "cannot compute suffix of object files: cannot compile +See \`config.log' for more details" "$LINENO" 5; } +fi +rm -f conftest.$ac_cv_objext conftest.$ac_ext +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 +$as_echo "$ac_cv_objext" >&6; } +OBJEXT=$ac_cv_objext +ac_objext=$OBJEXT +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 +$as_echo_n "checking whether we are using the GNU C compiler... " >&6; } +if ${ac_cv_c_compiler_gnu+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ +#ifndef __GNUC__ + choke me +#endif + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_compiler_gnu=yes +else + ac_compiler_gnu=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +ac_cv_c_compiler_gnu=$ac_compiler_gnu + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 +$as_echo "$ac_cv_c_compiler_gnu" >&6; } +if test $ac_compiler_gnu = yes; then + GCC=yes +else + GCC= +fi +ac_test_CFLAGS=${CFLAGS+set} +ac_save_CFLAGS=$CFLAGS +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 +$as_echo_n "checking whether $CC accepts -g... " >&6; } +if ${ac_cv_prog_cc_g+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_save_c_werror_flag=$ac_c_werror_flag + ac_c_werror_flag=yes + ac_cv_prog_cc_g=no + CFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_prog_cc_g=yes +else + CFLAGS="" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + +else + ac_c_werror_flag=$ac_save_c_werror_flag + CFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_prog_cc_g=yes +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + ac_c_werror_flag=$ac_save_c_werror_flag +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 +$as_echo "$ac_cv_prog_cc_g" >&6; } +if test "$ac_test_CFLAGS" = set; then + CFLAGS=$ac_save_CFLAGS +elif test $ac_cv_prog_cc_g = yes; then + if test "$GCC" = yes; then + CFLAGS="-g -O2" + else + CFLAGS="-g" + fi +else + if test "$GCC" = yes; then + CFLAGS="-O2" + else + CFLAGS= + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 +$as_echo_n "checking for $CC option to accept ISO C89... " >&6; } +if ${ac_cv_prog_cc_c89+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_cv_prog_cc_c89=no +ac_save_CC=$CC +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +struct stat; +/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ +struct buf { int x; }; +FILE * (*rcsopen) (struct buf *, struct stat *, int); +static char *e (p, i) + char **p; + int i; +{ + return p[i]; +} +static char *f (char * (*g) (char **, int), char **p, ...) +{ + char *s; + va_list v; + va_start (v,p); + s = g (p, va_arg (v,int)); + va_end (v); + return s; +} + +/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has + function prototypes and stuff, but not '\xHH' hex character constants. + These don't provoke an error unfortunately, instead are silently treated + as 'x'. The following induces an error, until -std is added to get + proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an + array size at least. It's necessary to write '\x00'==0 to get something + that's true only with -std. */ +int osf4_cc_array ['\x00' == 0 ? 1 : -1]; + +/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters + inside strings and character constants. */ +#define FOO(x) 'x' +int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; + +int test (int i, double x); +struct s1 {int (*f) (int a);}; +struct s2 {int (*f) (double a);}; +int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); +int argc; +char **argv; +int +main () +{ +return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; + ; + return 0; +} +_ACEOF +for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ + -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" +do + CC="$ac_save_CC $ac_arg" + if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_prog_cc_c89=$ac_arg +fi +rm -f core conftest.err conftest.$ac_objext + test "x$ac_cv_prog_cc_c89" != "xno" && break +done +rm -f conftest.$ac_ext +CC=$ac_save_CC + +fi +# AC_CACHE_VAL +case "x$ac_cv_prog_cc_c89" in + x) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +$as_echo "none needed" >&6; } ;; + xno) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +$as_echo "unsupported" >&6; } ;; + *) + CC="$CC $ac_cv_prog_cc_c89" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 +$as_echo "$ac_cv_prog_cc_c89" >&6; } ;; +esac +if test "x$ac_cv_prog_cc_c89" != xno; then : + +fi + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5 +$as_echo_n "checking whether $CC understands -c and -o together... " >&6; } +if ${am_cv_prog_cc_c_o+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF + # Make sure it works both with $CC and with simple cc. + # Following AC_PROG_CC_C_O, we do the test twice because some + # compilers refuse to overwrite an existing .o file with -o, + # though they will create one. + am_cv_prog_cc_c_o=yes + for am_i in 1 2; do + if { echo "$as_me:$LINENO: $CC -c conftest.$ac_ext -o conftest2.$ac_objext" >&5 + ($CC -c conftest.$ac_ext -o conftest2.$ac_objext) >&5 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } \ + && test -f conftest2.$ac_objext; then + : OK + else + am_cv_prog_cc_c_o=no + break + fi + done + rm -f core conftest* + unset am_i +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5 +$as_echo "$am_cv_prog_cc_c_o" >&6; } +if test "$am_cv_prog_cc_c_o" != yes; then + # Losing compiler, so override with the script. + # FIXME: It is wrong to rewrite CC. + # But if we don't then we get into trouble of one sort or another. + # A longer-term fix would be to have automake use am__CC in this case, + # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)" + CC="$am_aux_dir/compile $CC" +fi +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + +depcc="$CC" am_compiler_list= + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 +$as_echo_n "checking dependency style of $depcc... " >&6; } +if ${am_cv_CC_dependencies_compiler_type+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then + # We make a subdir and do the tests there. Otherwise we can end up + # making bogus files that we don't know about and never remove. For + # instance it was reported that on HP-UX the gcc test will end up + # making a dummy file named 'D' -- because '-MD' means "put the output + # in D". + rm -rf conftest.dir + mkdir conftest.dir + # Copy depcomp to subdir because otherwise we won't find it if we're + # using a relative directory. + cp "$am_depcomp" conftest.dir + cd conftest.dir + # We will build objects and dependencies in a subdirectory because + # it helps to detect inapplicable dependency modes. For instance + # both Tru64's cc and ICC support -MD to output dependencies as a + # side effect of compilation, but ICC will put the dependencies in + # the current directory while Tru64 will put them in the object + # directory. + mkdir sub + + am_cv_CC_dependencies_compiler_type=none + if test "$am_compiler_list" = ""; then + am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp` + fi + am__universal=false + case " $depcc " in #( + *\ -arch\ *\ -arch\ *) am__universal=true ;; + esac + + for depmode in $am_compiler_list; do + # Setup a source with many dependencies, because some compilers + # like to wrap large dependency lists on column 80 (with \), and + # we should not choose a depcomp mode which is confused by this. + # + # We need to recreate these files for each test, as the compiler may + # overwrite some of them when testing with obscure command lines. + # This happens at least with the AIX C compiler. + : > sub/conftest.c + for i in 1 2 3 4 5 6; do + echo '#include "conftst'$i'.h"' >> sub/conftest.c + # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with + # Solaris 10 /bin/sh. + echo '/* dummy */' > sub/conftst$i.h + done + echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf + + # We check with '-c' and '-o' for the sake of the "dashmstdout" + # mode. It turns out that the SunPro C++ compiler does not properly + # handle '-M -o', and we need to detect this. Also, some Intel + # versions had trouble with output in subdirs. + am__obj=sub/conftest.${OBJEXT-o} + am__minus_obj="-o $am__obj" + case $depmode in + gcc) + # This depmode causes a compiler race in universal mode. + test "$am__universal" = false || continue + ;; + nosideeffect) + # After this tag, mechanisms are not by side-effect, so they'll + # only be used when explicitly requested. + if test "x$enable_dependency_tracking" = xyes; then + continue + else + break + fi + ;; + msvc7 | msvc7msys | msvisualcpp | msvcmsys) + # This compiler won't grok '-c -o', but also, the minuso test has + # not run yet. These depmodes are late enough in the game, and + # so weak that their functioning should not be impacted. + am__obj=conftest.${OBJEXT-o} + am__minus_obj= + ;; + none) break ;; + esac + if depmode=$depmode \ + source=sub/conftest.c object=$am__obj \ + depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ + $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \ + >/dev/null 2>conftest.err && + grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && + grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && + grep $am__obj sub/conftest.Po > /dev/null 2>&1 && + ${MAKE-make} -s -f confmf > /dev/null 2>&1; then + # icc doesn't choke on unknown options, it will just issue warnings + # or remarks (even with -Werror). So we grep stderr for any message + # that says an option was ignored or not supported. + # When given -MP, icc 7.0 and 7.1 complain thusly: + # icc: Command line warning: ignoring option '-M'; no argument required + # The diagnosis changed in icc 8.0: + # icc: Command line remark: option '-MP' not supported + if (grep 'ignoring option' conftest.err || + grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else + am_cv_CC_dependencies_compiler_type=$depmode + break + fi + fi + done + + cd .. + rm -rf conftest.dir +else + am_cv_CC_dependencies_compiler_type=none +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5 +$as_echo "$am_cv_CC_dependencies_compiler_type" >&6; } +CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type + + if + test "x$enable_dependency_tracking" != xno \ + && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then + am__fastdepCC_TRUE= + am__fastdepCC_FALSE='#' +else + am__fastdepCC_TRUE='#' + am__fastdepCC_FALSE= +fi + + + +if test -n "$ac_tool_prefix"; then + for ac_prog in ar lib "link -lib" + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_AR+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$AR"; then + ac_cv_prog_AR="$AR" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_AR="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +AR=$ac_cv_prog_AR +if test -n "$AR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5 +$as_echo "$AR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$AR" && break + done +fi +if test -z "$AR"; then + ac_ct_AR=$AR + for ac_prog in ar lib "link -lib" +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_AR+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_AR"; then + ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_AR="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_AR=$ac_cv_prog_ac_ct_AR +if test -n "$ac_ct_AR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5 +$as_echo "$ac_ct_AR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_AR" && break +done + + if test "x$ac_ct_AR" = x; then + AR="false" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + AR=$ac_ct_AR + fi +fi + +: ${AR=ar} + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the archiver ($AR) interface" >&5 +$as_echo_n "checking the archiver ($AR) interface... " >&6; } +if ${am_cv_ar_interface+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + am_cv_ar_interface=ar + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +int some_variable = 0; +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + am_ar_try='$AR cru libconftest.a conftest.$ac_objext >&5' + { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$am_ar_try\""; } >&5 + (eval $am_ar_try) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + if test "$ac_status" -eq 0; then + am_cv_ar_interface=ar + else + am_ar_try='$AR -NOLOGO -OUT:conftest.lib conftest.$ac_objext >&5' + { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$am_ar_try\""; } >&5 + (eval $am_ar_try) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + if test "$ac_status" -eq 0; then + am_cv_ar_interface=lib + else + am_cv_ar_interface=unknown + fi + fi + rm -f conftest.lib libconftest.a + +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_ar_interface" >&5 +$as_echo "$am_cv_ar_interface" >&6; } + +case $am_cv_ar_interface in +ar) + ;; +lib) + # Microsoft lib, so override with the ar-lib wrapper script. + # FIXME: It is wrong to rewrite AR. + # But if we don't then we get into trouble of one sort or another. + # A longer-term fix would be to have automake use am__AR in this case, + # and then we could set am__AR="$am_aux_dir/ar-lib \$(AR)" or something + # similar. + AR="$am_aux_dir/ar-lib $AR" + ;; +unknown) + as_fn_error $? "could not determine $AR interface" "$LINENO" 5 + ;; +esac + + +# OpenFst does not throw exceptions, so we do not generate exception handling +# code. However, users are free to re-enable exception handling. +# OpenFst assumes char is unsigned; -fsigned-char is likely unsafe. +CPPFLAGS="$CPPFLAGS -fno-exceptions -funsigned-char" +CXXFLAGS="$CXXFLAGS -std=c++11" + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu +if test -z "$CXX"; then + if test -n "$CCC"; then + CXX=$CCC + else + if test -n "$ac_tool_prefix"; then + for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CXX"; then + ac_cv_prog_CXX="$CXX" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CXX="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CXX=$ac_cv_prog_CXX +if test -n "$CXX"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 +$as_echo "$CXX" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$CXX" && break + done +fi +if test -z "$CXX"; then + ac_ct_CXX=$CXX + for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_CXX"; then + ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CXX="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_CXX=$ac_cv_prog_ac_ct_CXX +if test -n "$ac_ct_CXX"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5 +$as_echo "$ac_ct_CXX" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_CXX" && break +done + + if test "x$ac_ct_CXX" = x; then + CXX="g++" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + CXX=$ac_ct_CXX + fi +fi + + fi +fi +# Provide some information about the compiler. +$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5 +set X $ac_compile +ac_compiler=$2 +for ac_option in --version -v -V -qversion; do + { { ac_try="$ac_compiler $ac_option >&5" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compiler $ac_option >&5") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + sed '10a\ +... rest of stderr output deleted ... + 10q' conftest.err >conftest.er1 + cat conftest.er1 >&5 + fi + rm -f conftest.er1 conftest.err + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } +done + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5 +$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; } +if ${ac_cv_cxx_compiler_gnu+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ +#ifndef __GNUC__ + choke me +#endif + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_compiler_gnu=yes +else + ac_compiler_gnu=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +ac_cv_cxx_compiler_gnu=$ac_compiler_gnu + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5 +$as_echo "$ac_cv_cxx_compiler_gnu" >&6; } +if test $ac_compiler_gnu = yes; then + GXX=yes +else + GXX= +fi +ac_test_CXXFLAGS=${CXXFLAGS+set} +ac_save_CXXFLAGS=$CXXFLAGS +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5 +$as_echo_n "checking whether $CXX accepts -g... " >&6; } +if ${ac_cv_prog_cxx_g+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_save_cxx_werror_flag=$ac_cxx_werror_flag + ac_cxx_werror_flag=yes + ac_cv_prog_cxx_g=no + CXXFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_cv_prog_cxx_g=yes +else + CXXFLAGS="" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + +else + ac_cxx_werror_flag=$ac_save_cxx_werror_flag + CXXFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_cv_prog_cxx_g=yes +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + ac_cxx_werror_flag=$ac_save_cxx_werror_flag +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5 +$as_echo "$ac_cv_prog_cxx_g" >&6; } +if test "$ac_test_CXXFLAGS" = set; then + CXXFLAGS=$ac_save_CXXFLAGS +elif test $ac_cv_prog_cxx_g = yes; then + if test "$GXX" = yes; then + CXXFLAGS="-g -O2" + else + CXXFLAGS="-g" + fi +else + if test "$GXX" = yes; then + CXXFLAGS="-O2" + else + CXXFLAGS= + fi +fi +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +depcc="$CXX" am_compiler_list= + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 +$as_echo_n "checking dependency style of $depcc... " >&6; } +if ${am_cv_CXX_dependencies_compiler_type+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then + # We make a subdir and do the tests there. Otherwise we can end up + # making bogus files that we don't know about and never remove. For + # instance it was reported that on HP-UX the gcc test will end up + # making a dummy file named 'D' -- because '-MD' means "put the output + # in D". + rm -rf conftest.dir + mkdir conftest.dir + # Copy depcomp to subdir because otherwise we won't find it if we're + # using a relative directory. + cp "$am_depcomp" conftest.dir + cd conftest.dir + # We will build objects and dependencies in a subdirectory because + # it helps to detect inapplicable dependency modes. For instance + # both Tru64's cc and ICC support -MD to output dependencies as a + # side effect of compilation, but ICC will put the dependencies in + # the current directory while Tru64 will put them in the object + # directory. + mkdir sub + + am_cv_CXX_dependencies_compiler_type=none + if test "$am_compiler_list" = ""; then + am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp` + fi + am__universal=false + case " $depcc " in #( + *\ -arch\ *\ -arch\ *) am__universal=true ;; + esac + + for depmode in $am_compiler_list; do + # Setup a source with many dependencies, because some compilers + # like to wrap large dependency lists on column 80 (with \), and + # we should not choose a depcomp mode which is confused by this. + # + # We need to recreate these files for each test, as the compiler may + # overwrite some of them when testing with obscure command lines. + # This happens at least with the AIX C compiler. + : > sub/conftest.c + for i in 1 2 3 4 5 6; do + echo '#include "conftst'$i'.h"' >> sub/conftest.c + # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with + # Solaris 10 /bin/sh. + echo '/* dummy */' > sub/conftst$i.h + done + echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf + + # We check with '-c' and '-o' for the sake of the "dashmstdout" + # mode. It turns out that the SunPro C++ compiler does not properly + # handle '-M -o', and we need to detect this. Also, some Intel + # versions had trouble with output in subdirs. + am__obj=sub/conftest.${OBJEXT-o} + am__minus_obj="-o $am__obj" + case $depmode in + gcc) + # This depmode causes a compiler race in universal mode. + test "$am__universal" = false || continue + ;; + nosideeffect) + # After this tag, mechanisms are not by side-effect, so they'll + # only be used when explicitly requested. + if test "x$enable_dependency_tracking" = xyes; then + continue + else + break + fi + ;; + msvc7 | msvc7msys | msvisualcpp | msvcmsys) + # This compiler won't grok '-c -o', but also, the minuso test has + # not run yet. These depmodes are late enough in the game, and + # so weak that their functioning should not be impacted. + am__obj=conftest.${OBJEXT-o} + am__minus_obj= + ;; + none) break ;; + esac + if depmode=$depmode \ + source=sub/conftest.c object=$am__obj \ + depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ + $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \ + >/dev/null 2>conftest.err && + grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && + grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && + grep $am__obj sub/conftest.Po > /dev/null 2>&1 && + ${MAKE-make} -s -f confmf > /dev/null 2>&1; then + # icc doesn't choke on unknown options, it will just issue warnings + # or remarks (even with -Werror). So we grep stderr for any message + # that says an option was ignored or not supported. + # When given -MP, icc 7.0 and 7.1 complain thusly: + # icc: Command line warning: ignoring option '-M'; no argument required + # The diagnosis changed in icc 8.0: + # icc: Command line remark: option '-MP' not supported + if (grep 'ignoring option' conftest.err || + grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else + am_cv_CXX_dependencies_compiler_type=$depmode + break + fi + fi + done + + cd .. + rm -rf conftest.dir +else + am_cv_CXX_dependencies_compiler_type=none +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5 +$as_echo "$am_cv_CXX_dependencies_compiler_type" >&6; } +CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type + + if + test "x$enable_dependency_tracking" != xno \ + && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then + am__fastdepCXX_TRUE= + am__fastdepCXX_FALSE='#' +else + am__fastdepCXX_TRUE='#' + am__fastdepCXX_FALSE= +fi + + +# Check whether --enable-static was given. +if test "${enable_static+set}" = set; then : + enableval=$enable_static; p=${PACKAGE-default} + case $enableval in + yes) enable_static=yes ;; + no) enable_static=no ;; + *) + enable_static=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_static=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac +else + enable_static=no +fi + + + + + + + + + +case `pwd` in + *\ * | *\ *) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5 +$as_echo "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;; +esac + + + +macro_version='2.4.2' +macro_revision='1.3337' + + + + + + + + + + + + + +ltmain="$ac_aux_dir/ltmain.sh" + +# Make sure we can run config.sub. +$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || + as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5 + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 +$as_echo_n "checking build system type... " >&6; } +if ${ac_cv_build+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_build_alias=$build_alias +test "x$ac_build_alias" = x && + ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"` +test "x$ac_build_alias" = x && + as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5 +ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` || + as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5 + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 +$as_echo "$ac_cv_build" >&6; } +case $ac_cv_build in +*-*-*) ;; +*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;; +esac +build=$ac_cv_build +ac_save_IFS=$IFS; IFS='-' +set x $ac_cv_build +shift +build_cpu=$1 +build_vendor=$2 +shift; shift +# Remember, the first character of IFS is used to create $*, +# except with old shells: +build_os=$* +IFS=$ac_save_IFS +case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 +$as_echo_n "checking host system type... " >&6; } +if ${ac_cv_host+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "x$host_alias" = x; then + ac_cv_host=$ac_cv_build +else + ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` || + as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5 +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 +$as_echo "$ac_cv_host" >&6; } +case $ac_cv_host in +*-*-*) ;; +*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;; +esac +host=$ac_cv_host +ac_save_IFS=$IFS; IFS='-' +set x $ac_cv_host +shift +host_cpu=$1 +host_vendor=$2 +shift; shift +# Remember, the first character of IFS is used to create $*, +# except with old shells: +host_os=$* +IFS=$ac_save_IFS +case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac + + +# Backslashify metacharacters that are still active within +# double-quoted strings. +sed_quote_subst='s/\(["`$\\]\)/\\\1/g' + +# Same as above, but do not quote variable references. +double_quote_subst='s/\(["`\\]\)/\\\1/g' + +# Sed substitution to delay expansion of an escaped shell variable in a +# double_quote_subst'ed string. +delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g' + +# Sed substitution to delay expansion of an escaped single quote. +delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g' + +# Sed substitution to avoid accidental globbing in evaled expressions +no_glob_subst='s/\*/\\\*/g' + +ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO +ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to print strings" >&5 +$as_echo_n "checking how to print strings... " >&6; } +# Test print first, because it will be a builtin if present. +if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \ + test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then + ECHO='print -r --' +elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then + ECHO='printf %s\n' +else + # Use this function as a fallback that always works. + func_fallback_echo () + { + eval 'cat <<_LTECHO_EOF +$1 +_LTECHO_EOF' + } + ECHO='func_fallback_echo' +fi + +# func_echo_all arg... +# Invoke $ECHO with all args, space-separated. +func_echo_all () +{ + $ECHO "" +} + +case "$ECHO" in + printf*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: printf" >&5 +$as_echo "printf" >&6; } ;; + print*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: print -r" >&5 +$as_echo "print -r" >&6; } ;; + *) { $as_echo "$as_me:${as_lineno-$LINENO}: result: cat" >&5 +$as_echo "cat" >&6; } ;; +esac + + + + + + + + + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5 +$as_echo_n "checking for a sed that does not truncate output... " >&6; } +if ${ac_cv_path_SED+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/ + for ac_i in 1 2 3 4 5 6 7; do + ac_script="$ac_script$as_nl$ac_script" + done + echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed + { ac_script=; unset ac_script;} + if test -z "$SED"; then + ac_path_SED_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in sed gsed; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_SED="$as_dir/$ac_prog$ac_exec_ext" + as_fn_executable_p "$ac_path_SED" || continue +# Check for GNU ac_path_SED and select it if it is found. + # Check for GNU $ac_path_SED +case `"$ac_path_SED" --version 2>&1` in +*GNU*) + ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;; +*) + ac_count=0 + $as_echo_n 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + $as_echo '' >> "conftest.nl" + "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break + diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break + as_fn_arith $ac_count + 1 && ac_count=$as_val + if test $ac_count -gt ${ac_path_SED_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_SED="$ac_path_SED" + ac_path_SED_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + + $ac_path_SED_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_SED"; then + as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5 + fi +else + ac_cv_path_SED=$SED +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5 +$as_echo "$ac_cv_path_SED" >&6; } + SED="$ac_cv_path_SED" + rm -f conftest.sed + +test -z "$SED" && SED=sed +Xsed="$SED -e 1s/^X//" + + + + + + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 +$as_echo_n "checking for grep that handles long lines and -e... " >&6; } +if ${ac_cv_path_GREP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$GREP"; then + ac_path_GREP_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in grep ggrep; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" + as_fn_executable_p "$ac_path_GREP" || continue +# Check for GNU ac_path_GREP and select it if it is found. + # Check for GNU $ac_path_GREP +case `"$ac_path_GREP" --version 2>&1` in +*GNU*) + ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; +*) + ac_count=0 + $as_echo_n 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + $as_echo 'GREP' >> "conftest.nl" + "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break + diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break + as_fn_arith $ac_count + 1 && ac_count=$as_val + if test $ac_count -gt ${ac_path_GREP_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_GREP="$ac_path_GREP" + ac_path_GREP_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + + $ac_path_GREP_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_GREP"; then + as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 + fi +else + ac_cv_path_GREP=$GREP +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 +$as_echo "$ac_cv_path_GREP" >&6; } + GREP="$ac_cv_path_GREP" + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 +$as_echo_n "checking for egrep... " >&6; } +if ${ac_cv_path_EGREP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 + then ac_cv_path_EGREP="$GREP -E" + else + if test -z "$EGREP"; then + ac_path_EGREP_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in egrep; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext" + as_fn_executable_p "$ac_path_EGREP" || continue +# Check for GNU ac_path_EGREP and select it if it is found. + # Check for GNU $ac_path_EGREP +case `"$ac_path_EGREP" --version 2>&1` in +*GNU*) + ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; +*) + ac_count=0 + $as_echo_n 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + $as_echo 'EGREP' >> "conftest.nl" + "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break + diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break + as_fn_arith $ac_count + 1 && ac_count=$as_val + if test $ac_count -gt ${ac_path_EGREP_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_EGREP="$ac_path_EGREP" + ac_path_EGREP_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + + $ac_path_EGREP_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_EGREP"; then + as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 + fi +else + ac_cv_path_EGREP=$EGREP +fi + + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 +$as_echo "$ac_cv_path_EGREP" >&6; } + EGREP="$ac_cv_path_EGREP" + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5 +$as_echo_n "checking for fgrep... " >&6; } +if ${ac_cv_path_FGREP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1 + then ac_cv_path_FGREP="$GREP -F" + else + if test -z "$FGREP"; then + ac_path_FGREP_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in fgrep; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext" + as_fn_executable_p "$ac_path_FGREP" || continue +# Check for GNU ac_path_FGREP and select it if it is found. + # Check for GNU $ac_path_FGREP +case `"$ac_path_FGREP" --version 2>&1` in +*GNU*) + ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;; +*) + ac_count=0 + $as_echo_n 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + $as_echo 'FGREP' >> "conftest.nl" + "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break + diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break + as_fn_arith $ac_count + 1 && ac_count=$as_val + if test $ac_count -gt ${ac_path_FGREP_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_FGREP="$ac_path_FGREP" + ac_path_FGREP_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + + $ac_path_FGREP_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_FGREP"; then + as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 + fi +else + ac_cv_path_FGREP=$FGREP +fi + + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5 +$as_echo "$ac_cv_path_FGREP" >&6; } + FGREP="$ac_cv_path_FGREP" + + +test -z "$GREP" && GREP=grep + + + + + + + + + + + + + + + + + + + +# Check whether --with-gnu-ld was given. +if test "${with_gnu_ld+set}" = set; then : + withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes +else + with_gnu_ld=no +fi + +ac_prog=ld +if test "$GCC" = yes; then + # Check if gcc -print-prog-name=ld gives a path. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 +$as_echo_n "checking for ld used by $CC... " >&6; } + case $host in + *-*-mingw*) + # gcc leaves a trailing carriage return which upsets mingw + ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; + *) + ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; + esac + case $ac_prog in + # Accept absolute paths. + [\\/]* | ?:[\\/]*) + re_direlt='/[^/][^/]*/\.\./' + # Canonicalize the pathname of ld + ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'` + while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do + ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"` + done + test -z "$LD" && LD="$ac_prog" + ;; + "") + # If it fails, then pretend we aren't using GCC. + ac_prog=ld + ;; + *) + # If it is relative, then search for the first ld in PATH. + with_gnu_ld=unknown + ;; + esac +elif test "$with_gnu_ld" = yes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 +$as_echo_n "checking for GNU ld... " >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5 +$as_echo_n "checking for non-GNU ld... " >&6; } +fi +if ${lt_cv_path_LD+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$LD"; then + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then + lt_cv_path_LD="$ac_dir/$ac_prog" + # Check to see if the program is GNU ld. I'd rather use --version, + # but apparently some variants of GNU ld only accept -v. + # Break only if it was the GNU/non-GNU ld that we prefer. + case `"$lt_cv_path_LD" -v 2>&1 &5 +$as_echo "$LD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi +test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5 +$as_echo_n "checking if the linker ($LD) is GNU ld... " >&6; } +if ${lt_cv_prog_gnu_ld+:} false; then : + $as_echo_n "(cached) " >&6 +else + # I'd rather use --version here, but apparently some GNU lds only accept -v. +case `$LD -v 2>&1 &5 +$as_echo "$lt_cv_prog_gnu_ld" >&6; } +with_gnu_ld=$lt_cv_prog_gnu_ld + + + + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5 +$as_echo_n "checking for BSD- or MS-compatible name lister (nm)... " >&6; } +if ${lt_cv_path_NM+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$NM"; then + # Let the user override the test. + lt_cv_path_NM="$NM" +else + lt_nm_to_check="${ac_tool_prefix}nm" + if test -n "$ac_tool_prefix" && test "$build" = "$host"; then + lt_nm_to_check="$lt_nm_to_check nm" + fi + for lt_tmp_nm in $lt_nm_to_check; do + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + tmp_nm="$ac_dir/$lt_tmp_nm" + if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then + # Check to see if the nm accepts a BSD-compat flag. + # Adding the `sed 1q' prevents false positives on HP-UX, which says: + # nm: unknown option "B" ignored + # Tru64's nm complains that /dev/null is an invalid object file + case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in + */dev/null* | *'Invalid file or object type'*) + lt_cv_path_NM="$tmp_nm -B" + break + ;; + *) + case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in + */dev/null*) + lt_cv_path_NM="$tmp_nm -p" + break + ;; + *) + lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but + continue # so that we can try to find one that supports BSD flags + ;; + esac + ;; + esac + fi + done + IFS="$lt_save_ifs" + done + : ${lt_cv_path_NM=no} +fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5 +$as_echo "$lt_cv_path_NM" >&6; } +if test "$lt_cv_path_NM" != "no"; then + NM="$lt_cv_path_NM" +else + # Didn't find any BSD compatible name lister, look for dumpbin. + if test -n "$DUMPBIN"; then : + # Let the user override the test. + else + if test -n "$ac_tool_prefix"; then + for ac_prog in dumpbin "link -dump" + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_DUMPBIN+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$DUMPBIN"; then + ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_DUMPBIN="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +DUMPBIN=$ac_cv_prog_DUMPBIN +if test -n "$DUMPBIN"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5 +$as_echo "$DUMPBIN" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$DUMPBIN" && break + done +fi +if test -z "$DUMPBIN"; then + ac_ct_DUMPBIN=$DUMPBIN + for ac_prog in dumpbin "link -dump" +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_DUMPBIN+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_DUMPBIN"; then + ac_cv_prog_ac_ct_DUMPBIN="$ac_ct_DUMPBIN" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_DUMPBIN="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN +if test -n "$ac_ct_DUMPBIN"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5 +$as_echo "$ac_ct_DUMPBIN" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_DUMPBIN" && break +done + + if test "x$ac_ct_DUMPBIN" = x; then + DUMPBIN=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + DUMPBIN=$ac_ct_DUMPBIN + fi +fi + + case `$DUMPBIN -symbols /dev/null 2>&1 | sed '1q'` in + *COFF*) + DUMPBIN="$DUMPBIN -symbols" + ;; + *) + DUMPBIN=: + ;; + esac + fi + + if test "$DUMPBIN" != ":"; then + NM="$DUMPBIN" + fi +fi +test -z "$NM" && NM=nm + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5 +$as_echo_n "checking the name lister ($NM) interface... " >&6; } +if ${lt_cv_nm_interface+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_nm_interface="BSD nm" + echo "int some_variable = 0;" > conftest.$ac_ext + (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&5) + (eval "$ac_compile" 2>conftest.err) + cat conftest.err >&5 + (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&5) + (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out) + cat conftest.err >&5 + (eval echo "\"\$as_me:$LINENO: output\"" >&5) + cat conftest.out >&5 + if $GREP 'External.*some_variable' conftest.out > /dev/null; then + lt_cv_nm_interface="MS dumpbin" + fi + rm -f conftest* +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5 +$as_echo "$lt_cv_nm_interface" >&6; } + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5 +$as_echo_n "checking whether ln -s works... " >&6; } +LN_S=$as_ln_s +if test "$LN_S" = "ln -s"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5 +$as_echo "no, using $LN_S" >&6; } +fi + +# find the maximum length of command line arguments +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5 +$as_echo_n "checking the maximum length of command line arguments... " >&6; } +if ${lt_cv_sys_max_cmd_len+:} false; then : + $as_echo_n "(cached) " >&6 +else + i=0 + teststring="ABCD" + + case $build_os in + msdosdjgpp*) + # On DJGPP, this test can blow up pretty badly due to problems in libc + # (any single argument exceeding 2000 bytes causes a buffer overrun + # during glob expansion). Even if it were fixed, the result of this + # check would be larger than it should be. + lt_cv_sys_max_cmd_len=12288; # 12K is about right + ;; + + gnu*) + # Under GNU Hurd, this test is not required because there is + # no limit to the length of command line arguments. + # Libtool will interpret -1 as no limit whatsoever + lt_cv_sys_max_cmd_len=-1; + ;; + + cygwin* | mingw* | cegcc*) + # On Win9x/ME, this test blows up -- it succeeds, but takes + # about 5 minutes as the teststring grows exponentially. + # Worse, since 9x/ME are not pre-emptively multitasking, + # you end up with a "frozen" computer, even though with patience + # the test eventually succeeds (with a max line length of 256k). + # Instead, let's just punt: use the minimum linelength reported by + # all of the supported platforms: 8192 (on NT/2K/XP). + lt_cv_sys_max_cmd_len=8192; + ;; + + mint*) + # On MiNT this can take a long time and run out of memory. + lt_cv_sys_max_cmd_len=8192; + ;; + + amigaos*) + # On AmigaOS with pdksh, this test takes hours, literally. + # So we just punt and use a minimum line length of 8192. + lt_cv_sys_max_cmd_len=8192; + ;; + + netbsd* | freebsd* | openbsd* | darwin* | dragonfly*) + # This has been around since 386BSD, at least. Likely further. + if test -x /sbin/sysctl; then + lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax` + elif test -x /usr/sbin/sysctl; then + lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax` + else + lt_cv_sys_max_cmd_len=65536 # usable default for all BSDs + fi + # And add a safety zone + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` + ;; + + interix*) + # We know the value 262144 and hardcode it with a safety zone (like BSD) + lt_cv_sys_max_cmd_len=196608 + ;; + + os2*) + # The test takes a long time on OS/2. + lt_cv_sys_max_cmd_len=8192 + ;; + + osf*) + # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure + # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not + # nice to cause kernel panics so lets avoid the loop below. + # First set a reasonable default. + lt_cv_sys_max_cmd_len=16384 + # + if test -x /sbin/sysconfig; then + case `/sbin/sysconfig -q proc exec_disable_arg_limit` in + *1*) lt_cv_sys_max_cmd_len=-1 ;; + esac + fi + ;; + sco3.2v5*) + lt_cv_sys_max_cmd_len=102400 + ;; + sysv5* | sco5v6* | sysv4.2uw2*) + kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null` + if test -n "$kargmax"; then + lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[ ]//'` + else + lt_cv_sys_max_cmd_len=32768 + fi + ;; + *) + lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null` + if test -n "$lt_cv_sys_max_cmd_len" && \ + test undefined != "$lt_cv_sys_max_cmd_len"; then + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` + else + # Make teststring a little bigger before we do anything with it. + # a 1K string should be a reasonable start. + for i in 1 2 3 4 5 6 7 8 ; do + teststring=$teststring$teststring + done + SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}} + # If test is not a shell built-in, we'll probably end up computing a + # maximum length that is only half of the actual maximum length, but + # we can't tell. + while { test "X"`env echo "$teststring$teststring" 2>/dev/null` \ + = "X$teststring$teststring"; } >/dev/null 2>&1 && + test $i != 17 # 1/2 MB should be enough + do + i=`expr $i + 1` + teststring=$teststring$teststring + done + # Only check the string length outside the loop. + lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1` + teststring= + # Add a significant safety factor because C++ compilers can tack on + # massive amounts of additional arguments before passing them to the + # linker. It appears as though 1/2 is a usable value. + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2` + fi + ;; + esac + +fi + +if test -n $lt_cv_sys_max_cmd_len ; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5 +$as_echo "$lt_cv_sys_max_cmd_len" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5 +$as_echo "none" >&6; } +fi +max_cmd_len=$lt_cv_sys_max_cmd_len + + + + + + +: ${CP="cp -f"} +: ${MV="mv -f"} +: ${RM="rm -f"} + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands some XSI constructs" >&5 +$as_echo_n "checking whether the shell understands some XSI constructs... " >&6; } +# Try some XSI features +xsi_shell=no +( _lt_dummy="a/b/c" + test "${_lt_dummy##*/},${_lt_dummy%/*},${_lt_dummy#??}"${_lt_dummy%"$_lt_dummy"}, \ + = c,a/b,b/c, \ + && eval 'test $(( 1 + 1 )) -eq 2 \ + && test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \ + && xsi_shell=yes +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $xsi_shell" >&5 +$as_echo "$xsi_shell" >&6; } + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands \"+=\"" >&5 +$as_echo_n "checking whether the shell understands \"+=\"... " >&6; } +lt_shell_append=no +( foo=bar; set foo baz; eval "$1+=\$2" && test "$foo" = barbaz ) \ + >/dev/null 2>&1 \ + && lt_shell_append=yes +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_shell_append" >&5 +$as_echo "$lt_shell_append" >&6; } + + +if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then + lt_unset=unset +else + lt_unset=false +fi + + + + + +# test EBCDIC or ASCII +case `echo X|tr X '\101'` in + A) # ASCII based system + # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr + lt_SP2NL='tr \040 \012' + lt_NL2SP='tr \015\012 \040\040' + ;; + *) # EBCDIC based system + lt_SP2NL='tr \100 \n' + lt_NL2SP='tr \r\n \100\100' + ;; +esac + + + + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to $host format" >&5 +$as_echo_n "checking how to convert $build file names to $host format... " >&6; } +if ${lt_cv_to_host_file_cmd+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $host in + *-*-mingw* ) + case $build in + *-*-mingw* ) # actually msys + lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32 + ;; + *-*-cygwin* ) + lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32 + ;; + * ) # otherwise, assume *nix + lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32 + ;; + esac + ;; + *-*-cygwin* ) + case $build in + *-*-mingw* ) # actually msys + lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin + ;; + *-*-cygwin* ) + lt_cv_to_host_file_cmd=func_convert_file_noop + ;; + * ) # otherwise, assume *nix + lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin + ;; + esac + ;; + * ) # unhandled hosts (and "normal" native builds) + lt_cv_to_host_file_cmd=func_convert_file_noop + ;; +esac + +fi + +to_host_file_cmd=$lt_cv_to_host_file_cmd +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_host_file_cmd" >&5 +$as_echo "$lt_cv_to_host_file_cmd" >&6; } + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to toolchain format" >&5 +$as_echo_n "checking how to convert $build file names to toolchain format... " >&6; } +if ${lt_cv_to_tool_file_cmd+:} false; then : + $as_echo_n "(cached) " >&6 +else + #assume ordinary cross tools, or native build. +lt_cv_to_tool_file_cmd=func_convert_file_noop +case $host in + *-*-mingw* ) + case $build in + *-*-mingw* ) # actually msys + lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32 + ;; + esac + ;; +esac + +fi + +to_tool_file_cmd=$lt_cv_to_tool_file_cmd +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_tool_file_cmd" >&5 +$as_echo "$lt_cv_to_tool_file_cmd" >&6; } + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5 +$as_echo_n "checking for $LD option to reload object files... " >&6; } +if ${lt_cv_ld_reload_flag+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_ld_reload_flag='-r' +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5 +$as_echo "$lt_cv_ld_reload_flag" >&6; } +reload_flag=$lt_cv_ld_reload_flag +case $reload_flag in +"" | " "*) ;; +*) reload_flag=" $reload_flag" ;; +esac +reload_cmds='$LD$reload_flag -o $output$reload_objs' +case $host_os in + cygwin* | mingw* | pw32* | cegcc*) + if test "$GCC" != yes; then + reload_cmds=false + fi + ;; + darwin*) + if test "$GCC" = yes; then + reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs' + else + reload_cmds='$LD$reload_flag -o $output$reload_objs' + fi + ;; +esac + + + + + + + + + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args. +set dummy ${ac_tool_prefix}objdump; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_OBJDUMP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$OBJDUMP"; then + ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +OBJDUMP=$ac_cv_prog_OBJDUMP +if test -n "$OBJDUMP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5 +$as_echo "$OBJDUMP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_OBJDUMP"; then + ac_ct_OBJDUMP=$OBJDUMP + # Extract the first word of "objdump", so it can be a program name with args. +set dummy objdump; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_OBJDUMP"; then + ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_OBJDUMP="objdump" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP +if test -n "$ac_ct_OBJDUMP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5 +$as_echo "$ac_ct_OBJDUMP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_OBJDUMP" = x; then + OBJDUMP="false" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + OBJDUMP=$ac_ct_OBJDUMP + fi +else + OBJDUMP="$ac_cv_prog_OBJDUMP" +fi + +test -z "$OBJDUMP" && OBJDUMP=objdump + + + + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to recognize dependent libraries" >&5 +$as_echo_n "checking how to recognize dependent libraries... " >&6; } +if ${lt_cv_deplibs_check_method+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_file_magic_cmd='$MAGIC_CMD' +lt_cv_file_magic_test_file= +lt_cv_deplibs_check_method='unknown' +# Need to set the preceding variable on all platforms that support +# interlibrary dependencies. +# 'none' -- dependencies not supported. +# `unknown' -- same as none, but documents that we really don't know. +# 'pass_all' -- all dependencies passed with no checks. +# 'test_compile' -- check by making test program. +# 'file_magic [[regex]]' -- check by looking for files in library path +# which responds to the $file_magic_cmd with a given extended regex. +# If you have `file' or equivalent on your system and you're not sure +# whether `pass_all' will *always* work, you probably want this one. + +case $host_os in +aix[4-9]*) + lt_cv_deplibs_check_method=pass_all + ;; + +beos*) + lt_cv_deplibs_check_method=pass_all + ;; + +bsdi[45]*) + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)' + lt_cv_file_magic_cmd='/usr/bin/file -L' + lt_cv_file_magic_test_file=/shlib/libc.so + ;; + +cygwin*) + # func_win32_libid is a shell function defined in ltmain.sh + lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL' + lt_cv_file_magic_cmd='func_win32_libid' + ;; + +mingw* | pw32*) + # Base MSYS/MinGW do not provide the 'file' command needed by + # func_win32_libid shell function, so use a weaker test based on 'objdump', + # unless we find 'file', for example because we are cross-compiling. + # func_win32_libid assumes BSD nm, so disallow it if using MS dumpbin. + if ( test "$lt_cv_nm_interface" = "BSD nm" && file / ) >/dev/null 2>&1; then + lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL' + lt_cv_file_magic_cmd='func_win32_libid' + else + # Keep this pattern in sync with the one in func_win32_libid. + lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' + lt_cv_file_magic_cmd='$OBJDUMP -f' + fi + ;; + +cegcc*) + # use the weaker test based on 'objdump'. See mingw*. + lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?' + lt_cv_file_magic_cmd='$OBJDUMP -f' + ;; + +darwin* | rhapsody*) + lt_cv_deplibs_check_method=pass_all + ;; + +freebsd* | dragonfly*) + if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then + case $host_cpu in + i*86 ) + # Not sure whether the presence of OpenBSD here was a mistake. + # Let's accept both of them until this is cleared up. + lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[3-9]86 (compact )?demand paged shared library' + lt_cv_file_magic_cmd=/usr/bin/file + lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*` + ;; + esac + else + lt_cv_deplibs_check_method=pass_all + fi + ;; + +haiku*) + lt_cv_deplibs_check_method=pass_all + ;; + +hpux10.20* | hpux11*) + lt_cv_file_magic_cmd=/usr/bin/file + case $host_cpu in + ia64*) + lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64' + lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so + ;; + hppa*64*) + lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF[ -][0-9][0-9])(-bit)?( [LM]SB)? shared object( file)?[, -]* PA-RISC [0-9]\.[0-9]' + lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl + ;; + *) + lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9]\.[0-9]) shared library' + lt_cv_file_magic_test_file=/usr/lib/libc.sl + ;; + esac + ;; + +interix[3-9]*) + # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here + lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|\.a)$' + ;; + +irix5* | irix6* | nonstopux*) + case $LD in + *-32|*"-32 ") libmagic=32-bit;; + *-n32|*"-n32 ") libmagic=N32;; + *-64|*"-64 ") libmagic=64-bit;; + *) libmagic=never-match;; + esac + lt_cv_deplibs_check_method=pass_all + ;; + +# This must be glibc/ELF. +linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + lt_cv_deplibs_check_method=pass_all + ;; + +netbsd* | netbsdelf*-gnu) + if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then + lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$' + else + lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|_pic\.a)$' + fi + ;; + +newos6*) + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)' + lt_cv_file_magic_cmd=/usr/bin/file + lt_cv_file_magic_test_file=/usr/lib/libnls.so + ;; + +*nto* | *qnx*) + lt_cv_deplibs_check_method=pass_all + ;; + +openbsd*) + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|\.so|_pic\.a)$' + else + lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$' + fi + ;; + +osf3* | osf4* | osf5*) + lt_cv_deplibs_check_method=pass_all + ;; + +rdos*) + lt_cv_deplibs_check_method=pass_all + ;; + +solaris*) + lt_cv_deplibs_check_method=pass_all + ;; + +sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) + lt_cv_deplibs_check_method=pass_all + ;; + +sysv4 | sysv4.3*) + case $host_vendor in + motorola) + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]' + lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*` + ;; + ncr) + lt_cv_deplibs_check_method=pass_all + ;; + sequent) + lt_cv_file_magic_cmd='/bin/file' + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )' + ;; + sni) + lt_cv_file_magic_cmd='/bin/file' + lt_cv_deplibs_check_method="file_magic ELF [0-9][0-9]*-bit [LM]SB dynamic lib" + lt_cv_file_magic_test_file=/lib/libc.so + ;; + siemens) + lt_cv_deplibs_check_method=pass_all + ;; + pc) + lt_cv_deplibs_check_method=pass_all + ;; + esac + ;; + +tpf*) + lt_cv_deplibs_check_method=pass_all + ;; +esac + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method" >&5 +$as_echo "$lt_cv_deplibs_check_method" >&6; } + +file_magic_glob= +want_nocaseglob=no +if test "$build" = "$host"; then + case $host_os in + mingw* | pw32*) + if ( shopt | grep nocaseglob ) >/dev/null 2>&1; then + want_nocaseglob=yes + else + file_magic_glob=`echo aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ | $SED -e "s/\(..\)/s\/[\1]\/[\1]\/g;/g"` + fi + ;; + esac +fi + +file_magic_cmd=$lt_cv_file_magic_cmd +deplibs_check_method=$lt_cv_deplibs_check_method +test -z "$deplibs_check_method" && deplibs_check_method=unknown + + + + + + + + + + + + + + + + + + + + + + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args. +set dummy ${ac_tool_prefix}dlltool; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_DLLTOOL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$DLLTOOL"; then + ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +DLLTOOL=$ac_cv_prog_DLLTOOL +if test -n "$DLLTOOL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5 +$as_echo "$DLLTOOL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_DLLTOOL"; then + ac_ct_DLLTOOL=$DLLTOOL + # Extract the first word of "dlltool", so it can be a program name with args. +set dummy dlltool; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_DLLTOOL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_DLLTOOL"; then + ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_DLLTOOL="dlltool" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL +if test -n "$ac_ct_DLLTOOL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5 +$as_echo "$ac_ct_DLLTOOL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_DLLTOOL" = x; then + DLLTOOL="false" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + DLLTOOL=$ac_ct_DLLTOOL + fi +else + DLLTOOL="$ac_cv_prog_DLLTOOL" +fi + +test -z "$DLLTOOL" && DLLTOOL=dlltool + + + + + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to associate runtime and link libraries" >&5 +$as_echo_n "checking how to associate runtime and link libraries... " >&6; } +if ${lt_cv_sharedlib_from_linklib_cmd+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_sharedlib_from_linklib_cmd='unknown' + +case $host_os in +cygwin* | mingw* | pw32* | cegcc*) + # two different shell functions defined in ltmain.sh + # decide which to use based on capabilities of $DLLTOOL + case `$DLLTOOL --help 2>&1` in + *--identify-strict*) + lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib + ;; + *) + lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib_fallback + ;; + esac + ;; +*) + # fallback: assume linklib IS sharedlib + lt_cv_sharedlib_from_linklib_cmd="$ECHO" + ;; +esac + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sharedlib_from_linklib_cmd" >&5 +$as_echo "$lt_cv_sharedlib_from_linklib_cmd" >&6; } +sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd +test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO + + + + + + + +if test -n "$ac_tool_prefix"; then + for ac_prog in ar + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_AR+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$AR"; then + ac_cv_prog_AR="$AR" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_AR="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +AR=$ac_cv_prog_AR +if test -n "$AR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5 +$as_echo "$AR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$AR" && break + done +fi +if test -z "$AR"; then + ac_ct_AR=$AR + for ac_prog in ar +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_AR+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_AR"; then + ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_AR="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_AR=$ac_cv_prog_ac_ct_AR +if test -n "$ac_ct_AR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5 +$as_echo "$ac_ct_AR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_AR" && break +done + + if test "x$ac_ct_AR" = x; then + AR="false" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + AR=$ac_ct_AR + fi +fi + +: ${AR=ar} +: ${AR_FLAGS=cru} + + + + + + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for archiver @FILE support" >&5 +$as_echo_n "checking for archiver @FILE support... " >&6; } +if ${lt_cv_ar_at_file+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_ar_at_file=no + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + echo conftest.$ac_objext > conftest.lst + lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&5' + { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5 + (eval $lt_ar_try) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + if test "$ac_status" -eq 0; then + # Ensure the archiver fails upon bogus file names. + rm -f conftest.$ac_objext libconftest.a + { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5 + (eval $lt_ar_try) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + if test "$ac_status" -ne 0; then + lt_cv_ar_at_file=@ + fi + fi + rm -f conftest.* libconftest.a + +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ar_at_file" >&5 +$as_echo "$lt_cv_ar_at_file" >&6; } + +if test "x$lt_cv_ar_at_file" = xno; then + archiver_list_spec= +else + archiver_list_spec=$lt_cv_ar_at_file +fi + + + + + + + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. +set dummy ${ac_tool_prefix}strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_STRIP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$STRIP"; then + ac_cv_prog_STRIP="$STRIP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_STRIP="${ac_tool_prefix}strip" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +STRIP=$ac_cv_prog_STRIP +if test -n "$STRIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 +$as_echo "$STRIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_STRIP"; then + ac_ct_STRIP=$STRIP + # Extract the first word of "strip", so it can be a program name with args. +set dummy strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_STRIP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_STRIP"; then + ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_STRIP="strip" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP +if test -n "$ac_ct_STRIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 +$as_echo "$ac_ct_STRIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_STRIP" = x; then + STRIP=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + STRIP=$ac_ct_STRIP + fi +else + STRIP="$ac_cv_prog_STRIP" +fi + +test -z "$STRIP" && STRIP=: + + + + + + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args. +set dummy ${ac_tool_prefix}ranlib; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_RANLIB+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$RANLIB"; then + ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +RANLIB=$ac_cv_prog_RANLIB +if test -n "$RANLIB"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5 +$as_echo "$RANLIB" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_RANLIB"; then + ac_ct_RANLIB=$RANLIB + # Extract the first word of "ranlib", so it can be a program name with args. +set dummy ranlib; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_RANLIB+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_RANLIB"; then + ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_RANLIB="ranlib" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB +if test -n "$ac_ct_RANLIB"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5 +$as_echo "$ac_ct_RANLIB" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_RANLIB" = x; then + RANLIB=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + RANLIB=$ac_ct_RANLIB + fi +else + RANLIB="$ac_cv_prog_RANLIB" +fi + +test -z "$RANLIB" && RANLIB=: + + + + + + +# Determine commands to create old-style static archives. +old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs' +old_postinstall_cmds='chmod 644 $oldlib' +old_postuninstall_cmds= + +if test -n "$RANLIB"; then + case $host_os in + openbsd*) + old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib" + ;; + *) + old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib" + ;; + esac + old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_oldlib" +fi + +case $host_os in + darwin*) + lock_old_archive_extraction=yes ;; + *) + lock_old_archive_extraction=no ;; +esac + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# If no C compiler flags were specified, use CFLAGS. +LTCFLAGS=${LTCFLAGS-"$CFLAGS"} + +# Allow CC to be a program name with arguments. +compiler=$CC + + +# Check for command to grab the raw symbol name followed by C symbol from nm. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking command to parse $NM output from $compiler object" >&5 +$as_echo_n "checking command to parse $NM output from $compiler object... " >&6; } +if ${lt_cv_sys_global_symbol_pipe+:} false; then : + $as_echo_n "(cached) " >&6 +else + +# These are sane defaults that work on at least a few old systems. +# [They come from Ultrix. What could be older than Ultrix?!! ;)] + +# Character class describing NM global symbol codes. +symcode='[BCDEGRST]' + +# Regexp to match symbols that can be accessed directly from C. +sympat='\([_A-Za-z][_A-Za-z0-9]*\)' + +# Define system-specific variables. +case $host_os in +aix*) + symcode='[BCDT]' + ;; +cygwin* | mingw* | pw32* | cegcc*) + symcode='[ABCDGISTW]' + ;; +hpux*) + if test "$host_cpu" = ia64; then + symcode='[ABCDEGRST]' + fi + ;; +irix* | nonstopux*) + symcode='[BCDEGRST]' + ;; +osf*) + symcode='[BCDEGQRST]' + ;; +solaris*) + symcode='[BDRT]' + ;; +sco3.2v5*) + symcode='[DT]' + ;; +sysv4.2uw2*) + symcode='[DT]' + ;; +sysv5* | sco5v6* | unixware* | OpenUNIX*) + symcode='[ABDT]' + ;; +sysv4) + symcode='[DFNSTU]' + ;; +esac + +# If we're using GNU nm, then use its standard symbol codes. +case `$NM -V 2>&1` in +*GNU* | *'with BFD'*) + symcode='[ABCDGIRSTW]' ;; +esac + +# Transform an extracted symbol line into a proper C declaration. +# Some systems (esp. on ia64) link data and code symbols differently, +# so use this general approach. +lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'" + +# Transform an extracted symbol line into symbol name and symbol address +lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\)[ ]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/ {\"\2\", (void *) \&\2},/p'" +lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \([^ ]*\)[ ]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([^ ]*\) \(lib[^ ]*\)$/ {\"\2\", (void *) \&\2},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/ {\"lib\2\", (void *) \&\2},/p'" + +# Handle CRLF in mingw tool chain +opt_cr= +case $build_os in +mingw*) + opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp + ;; +esac + +# Try without a prefix underscore, then with it. +for ac_symprfx in "" "_"; do + + # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol. + symxfrm="\\1 $ac_symprfx\\2 \\2" + + # Write the raw and C identifiers. + if test "$lt_cv_nm_interface" = "MS dumpbin"; then + # Fake it for dumpbin and say T for any non-static function + # and D for any global variable. + # Also find C++ and __fastcall symbols from MSVC++, + # which start with @ or ?. + lt_cv_sys_global_symbol_pipe="$AWK '"\ +" {last_section=section; section=\$ 3};"\ +" /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\ +" /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\ +" \$ 0!~/External *\|/{next};"\ +" / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\ +" {if(hide[section]) next};"\ +" {f=0}; \$ 0~/\(\).*\|/{f=1}; {printf f ? \"T \" : \"D \"};"\ +" {split(\$ 0, a, /\||\r/); split(a[2], s)};"\ +" s[1]~/^[@?]/{print s[1], s[1]; next};"\ +" s[1]~prfx {split(s[1],t,\"@\"); print t[1], substr(t[1],length(prfx))}"\ +" ' prfx=^$ac_symprfx" + else + lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[ ]\($symcode$symcode*\)[ ][ ]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'" + fi + lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | sed '/ __gnu_lto/d'" + + # Check to see that the pipe works correctly. + pipe_works=no + + rm -f conftest* + cat > conftest.$ac_ext <<_LT_EOF +#ifdef __cplusplus +extern "C" { +#endif +char nm_test_var; +void nm_test_func(void); +void nm_test_func(void){} +#ifdef __cplusplus +} +#endif +int main(){nm_test_var='a';nm_test_func();return(0);} +_LT_EOF + + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + # Now try to grab the symbols. + nlist=conftest.nm + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist\""; } >&5 + (eval $NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s "$nlist"; then + # Try sorting and uniquifying the output. + if sort "$nlist" | uniq > "$nlist"T; then + mv -f "$nlist"T "$nlist" + else + rm -f "$nlist"T + fi + + # Make sure that we snagged all the symbols we need. + if $GREP ' nm_test_var$' "$nlist" >/dev/null; then + if $GREP ' nm_test_func$' "$nlist" >/dev/null; then + cat <<_LT_EOF > conftest.$ac_ext +/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */ +#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE) +/* DATA imports from DLLs on WIN32 con't be const, because runtime + relocations are performed -- see ld's documentation on pseudo-relocs. */ +# define LT_DLSYM_CONST +#elif defined(__osf__) +/* This system does not cope well with relocations in const data. */ +# define LT_DLSYM_CONST +#else +# define LT_DLSYM_CONST const +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +_LT_EOF + # Now generate the symbol file. + eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext' + + cat <<_LT_EOF >> conftest.$ac_ext + +/* The mapping between symbol names and symbols. */ +LT_DLSYM_CONST struct { + const char *name; + void *address; +} +lt__PROGRAM__LTX_preloaded_symbols[] = +{ + { "@PROGRAM@", (void *) 0 }, +_LT_EOF + $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/ {\"\2\", (void *) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext + cat <<\_LT_EOF >> conftest.$ac_ext + {0, (void *) 0} +}; + +/* This works around a problem in FreeBSD linker */ +#ifdef FREEBSD_WORKAROUND +static const void *lt_preloaded_setup() { + return lt__PROGRAM__LTX_preloaded_symbols; +} +#endif + +#ifdef __cplusplus +} +#endif +_LT_EOF + # Now try linking the two files. + mv conftest.$ac_objext conftstm.$ac_objext + lt_globsym_save_LIBS=$LIBS + lt_globsym_save_CFLAGS=$CFLAGS + LIBS="conftstm.$ac_objext" + CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag" + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s conftest${ac_exeext}; then + pipe_works=yes + fi + LIBS=$lt_globsym_save_LIBS + CFLAGS=$lt_globsym_save_CFLAGS + else + echo "cannot find nm_test_func in $nlist" >&5 + fi + else + echo "cannot find nm_test_var in $nlist" >&5 + fi + else + echo "cannot run $lt_cv_sys_global_symbol_pipe" >&5 + fi + else + echo "$progname: failed program was:" >&5 + cat conftest.$ac_ext >&5 + fi + rm -rf conftest* conftst* + + # Do not use the global_symbol_pipe unless it works. + if test "$pipe_works" = yes; then + break + else + lt_cv_sys_global_symbol_pipe= + fi +done + +fi + +if test -z "$lt_cv_sys_global_symbol_pipe"; then + lt_cv_sys_global_symbol_to_cdecl= +fi +if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5 +$as_echo "failed" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 +$as_echo "ok" >&6; } +fi + +# Response file support. +if test "$lt_cv_nm_interface" = "MS dumpbin"; then + nm_file_list_spec='@' +elif $NM --help 2>/dev/null | grep '[@]FILE' >/dev/null; then + nm_file_list_spec='@' +fi + + + + + + + + + + + + + + + + + + + + + + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5 +$as_echo_n "checking for sysroot... " >&6; } + +# Check whether --with-sysroot was given. +if test "${with_sysroot+set}" = set; then : + withval=$with_sysroot; +else + with_sysroot=no +fi + + +lt_sysroot= +case ${with_sysroot} in #( + yes) + if test "$GCC" = yes; then + lt_sysroot=`$CC --print-sysroot 2>/dev/null` + fi + ;; #( + /*) + lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"` + ;; #( + no|'') + ;; #( + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${with_sysroot}" >&5 +$as_echo "${with_sysroot}" >&6; } + as_fn_error $? "The sysroot must be an absolute path." "$LINENO" 5 + ;; +esac + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${lt_sysroot:-no}" >&5 +$as_echo "${lt_sysroot:-no}" >&6; } + + + + + +# Check whether --enable-libtool-lock was given. +if test "${enable_libtool_lock+set}" = set; then : + enableval=$enable_libtool_lock; +fi + +test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes + +# Some flags need to be propagated to the compiler or linker for good +# libtool support. +case $host in +ia64-*-hpux*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + case `/usr/bin/file conftest.$ac_objext` in + *ELF-32*) + HPUX_IA64_MODE="32" + ;; + *ELF-64*) + HPUX_IA64_MODE="64" + ;; + esac + fi + rm -rf conftest* + ;; +*-*-irix6*) + # Find out which ABI we are using. + echo '#line '$LINENO' "configure"' > conftest.$ac_ext + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + if test "$lt_cv_prog_gnu_ld" = yes; then + case `/usr/bin/file conftest.$ac_objext` in + *32-bit*) + LD="${LD-ld} -melf32bsmip" + ;; + *N32*) + LD="${LD-ld} -melf32bmipn32" + ;; + *64-bit*) + LD="${LD-ld} -melf64bmip" + ;; + esac + else + case `/usr/bin/file conftest.$ac_objext` in + *32-bit*) + LD="${LD-ld} -32" + ;; + *N32*) + LD="${LD-ld} -n32" + ;; + *64-bit*) + LD="${LD-ld} -64" + ;; + esac + fi + fi + rm -rf conftest* + ;; + +x86_64-*kfreebsd*-gnu|x86_64-*linux*|powerpc*-*linux*| \ +s390*-*linux*|s390*-*tpf*|sparc*-*linux*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + case `/usr/bin/file conftest.o` in + *32-bit*) + case $host in + x86_64-*kfreebsd*-gnu) + LD="${LD-ld} -m elf_i386_fbsd" + ;; + x86_64-*linux*) + case `/usr/bin/file conftest.o` in + *x86-64*) + LD="${LD-ld} -m elf32_x86_64" + ;; + *) + LD="${LD-ld} -m elf_i386" + ;; + esac + ;; + powerpc64le-*) + LD="${LD-ld} -m elf32lppclinux" + ;; + powerpc64-*) + LD="${LD-ld} -m elf32ppclinux" + ;; + s390x-*linux*) + LD="${LD-ld} -m elf_s390" + ;; + sparc64-*linux*) + LD="${LD-ld} -m elf32_sparc" + ;; + esac + ;; + *64-bit*) + case $host in + x86_64-*kfreebsd*-gnu) + LD="${LD-ld} -m elf_x86_64_fbsd" + ;; + x86_64-*linux*) + LD="${LD-ld} -m elf_x86_64" + ;; + powerpcle-*) + LD="${LD-ld} -m elf64lppc" + ;; + powerpc-*) + LD="${LD-ld} -m elf64ppc" + ;; + s390*-*linux*|s390*-*tpf*) + LD="${LD-ld} -m elf64_s390" + ;; + sparc*-*linux*) + LD="${LD-ld} -m elf64_sparc" + ;; + esac + ;; + esac + fi + rm -rf conftest* + ;; + +*-*-sco3.2v5*) + # On SCO OpenServer 5, we need -belf to get full-featured binaries. + SAVE_CFLAGS="$CFLAGS" + CFLAGS="$CFLAGS -belf" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5 +$as_echo_n "checking whether the C compiler needs -belf... " >&6; } +if ${lt_cv_cc_needs_belf+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + lt_cv_cc_needs_belf=yes +else + lt_cv_cc_needs_belf=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5 +$as_echo "$lt_cv_cc_needs_belf" >&6; } + if test x"$lt_cv_cc_needs_belf" != x"yes"; then + # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf + CFLAGS="$SAVE_CFLAGS" + fi + ;; +*-*solaris*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + case `/usr/bin/file conftest.o` in + *64-bit*) + case $lt_cv_prog_gnu_ld in + yes*) + case $host in + i?86-*-solaris*) + LD="${LD-ld} -m elf_x86_64" + ;; + sparc*-*-solaris*) + LD="${LD-ld} -m elf64_sparc" + ;; + esac + # GNU ld 2.21 introduced _sol2 emulations. Use them if available. + if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then + LD="${LD-ld}_sol2" + fi + ;; + *) + if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then + LD="${LD-ld} -64" + fi + ;; + esac + ;; + esac + fi + rm -rf conftest* + ;; +esac + +need_locks="$enable_libtool_lock" + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}mt", so it can be a program name with args. +set dummy ${ac_tool_prefix}mt; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_MANIFEST_TOOL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$MANIFEST_TOOL"; then + ac_cv_prog_MANIFEST_TOOL="$MANIFEST_TOOL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_MANIFEST_TOOL="${ac_tool_prefix}mt" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +MANIFEST_TOOL=$ac_cv_prog_MANIFEST_TOOL +if test -n "$MANIFEST_TOOL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MANIFEST_TOOL" >&5 +$as_echo "$MANIFEST_TOOL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_MANIFEST_TOOL"; then + ac_ct_MANIFEST_TOOL=$MANIFEST_TOOL + # Extract the first word of "mt", so it can be a program name with args. +set dummy mt; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_MANIFEST_TOOL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_MANIFEST_TOOL"; then + ac_cv_prog_ac_ct_MANIFEST_TOOL="$ac_ct_MANIFEST_TOOL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_MANIFEST_TOOL="mt" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_MANIFEST_TOOL=$ac_cv_prog_ac_ct_MANIFEST_TOOL +if test -n "$ac_ct_MANIFEST_TOOL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_MANIFEST_TOOL" >&5 +$as_echo "$ac_ct_MANIFEST_TOOL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_MANIFEST_TOOL" = x; then + MANIFEST_TOOL=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + MANIFEST_TOOL=$ac_ct_MANIFEST_TOOL + fi +else + MANIFEST_TOOL="$ac_cv_prog_MANIFEST_TOOL" +fi + +test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $MANIFEST_TOOL is a manifest tool" >&5 +$as_echo_n "checking if $MANIFEST_TOOL is a manifest tool... " >&6; } +if ${lt_cv_path_mainfest_tool+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_path_mainfest_tool=no + echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&5 + $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out + cat conftest.err >&5 + if $GREP 'Manifest Tool' conftest.out > /dev/null; then + lt_cv_path_mainfest_tool=yes + fi + rm -f conftest* +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_mainfest_tool" >&5 +$as_echo "$lt_cv_path_mainfest_tool" >&6; } +if test "x$lt_cv_path_mainfest_tool" != xyes; then + MANIFEST_TOOL=: +fi + + + + + + + case $host_os in + rhapsody* | darwin*) + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}dsymutil", so it can be a program name with args. +set dummy ${ac_tool_prefix}dsymutil; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_DSYMUTIL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$DSYMUTIL"; then + ac_cv_prog_DSYMUTIL="$DSYMUTIL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_DSYMUTIL="${ac_tool_prefix}dsymutil" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +DSYMUTIL=$ac_cv_prog_DSYMUTIL +if test -n "$DSYMUTIL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5 +$as_echo "$DSYMUTIL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_DSYMUTIL"; then + ac_ct_DSYMUTIL=$DSYMUTIL + # Extract the first word of "dsymutil", so it can be a program name with args. +set dummy dsymutil; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_DSYMUTIL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_DSYMUTIL"; then + ac_cv_prog_ac_ct_DSYMUTIL="$ac_ct_DSYMUTIL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_DSYMUTIL="dsymutil" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_DSYMUTIL=$ac_cv_prog_ac_ct_DSYMUTIL +if test -n "$ac_ct_DSYMUTIL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DSYMUTIL" >&5 +$as_echo "$ac_ct_DSYMUTIL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_DSYMUTIL" = x; then + DSYMUTIL=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + DSYMUTIL=$ac_ct_DSYMUTIL + fi +else + DSYMUTIL="$ac_cv_prog_DSYMUTIL" +fi + + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}nmedit", so it can be a program name with args. +set dummy ${ac_tool_prefix}nmedit; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_NMEDIT+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$NMEDIT"; then + ac_cv_prog_NMEDIT="$NMEDIT" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_NMEDIT="${ac_tool_prefix}nmedit" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +NMEDIT=$ac_cv_prog_NMEDIT +if test -n "$NMEDIT"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NMEDIT" >&5 +$as_echo "$NMEDIT" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_NMEDIT"; then + ac_ct_NMEDIT=$NMEDIT + # Extract the first word of "nmedit", so it can be a program name with args. +set dummy nmedit; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_NMEDIT+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_NMEDIT"; then + ac_cv_prog_ac_ct_NMEDIT="$ac_ct_NMEDIT" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_NMEDIT="nmedit" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_NMEDIT=$ac_cv_prog_ac_ct_NMEDIT +if test -n "$ac_ct_NMEDIT"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NMEDIT" >&5 +$as_echo "$ac_ct_NMEDIT" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_NMEDIT" = x; then + NMEDIT=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + NMEDIT=$ac_ct_NMEDIT + fi +else + NMEDIT="$ac_cv_prog_NMEDIT" +fi + + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}lipo", so it can be a program name with args. +set dummy ${ac_tool_prefix}lipo; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_LIPO+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$LIPO"; then + ac_cv_prog_LIPO="$LIPO" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_LIPO="${ac_tool_prefix}lipo" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +LIPO=$ac_cv_prog_LIPO +if test -n "$LIPO"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5 +$as_echo "$LIPO" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_LIPO"; then + ac_ct_LIPO=$LIPO + # Extract the first word of "lipo", so it can be a program name with args. +set dummy lipo; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_LIPO+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_LIPO"; then + ac_cv_prog_ac_ct_LIPO="$ac_ct_LIPO" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_LIPO="lipo" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_LIPO=$ac_cv_prog_ac_ct_LIPO +if test -n "$ac_ct_LIPO"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_LIPO" >&5 +$as_echo "$ac_ct_LIPO" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_LIPO" = x; then + LIPO=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + LIPO=$ac_ct_LIPO + fi +else + LIPO="$ac_cv_prog_LIPO" +fi + + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}otool", so it can be a program name with args. +set dummy ${ac_tool_prefix}otool; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_OTOOL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$OTOOL"; then + ac_cv_prog_OTOOL="$OTOOL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_OTOOL="${ac_tool_prefix}otool" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +OTOOL=$ac_cv_prog_OTOOL +if test -n "$OTOOL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5 +$as_echo "$OTOOL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_OTOOL"; then + ac_ct_OTOOL=$OTOOL + # Extract the first word of "otool", so it can be a program name with args. +set dummy otool; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_OTOOL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_OTOOL"; then + ac_cv_prog_ac_ct_OTOOL="$ac_ct_OTOOL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_OTOOL="otool" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_OTOOL=$ac_cv_prog_ac_ct_OTOOL +if test -n "$ac_ct_OTOOL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL" >&5 +$as_echo "$ac_ct_OTOOL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_OTOOL" = x; then + OTOOL=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + OTOOL=$ac_ct_OTOOL + fi +else + OTOOL="$ac_cv_prog_OTOOL" +fi + + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}otool64", so it can be a program name with args. +set dummy ${ac_tool_prefix}otool64; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_OTOOL64+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$OTOOL64"; then + ac_cv_prog_OTOOL64="$OTOOL64" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_OTOOL64="${ac_tool_prefix}otool64" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +OTOOL64=$ac_cv_prog_OTOOL64 +if test -n "$OTOOL64"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL64" >&5 +$as_echo "$OTOOL64" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_OTOOL64"; then + ac_ct_OTOOL64=$OTOOL64 + # Extract the first word of "otool64", so it can be a program name with args. +set dummy otool64; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_OTOOL64+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_OTOOL64"; then + ac_cv_prog_ac_ct_OTOOL64="$ac_ct_OTOOL64" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_OTOOL64="otool64" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_OTOOL64=$ac_cv_prog_ac_ct_OTOOL64 +if test -n "$ac_ct_OTOOL64"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL64" >&5 +$as_echo "$ac_ct_OTOOL64" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_OTOOL64" = x; then + OTOOL64=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + OTOOL64=$ac_ct_OTOOL64 + fi +else + OTOOL64="$ac_cv_prog_OTOOL64" +fi + + + + + + + + + + + + + + + + + + + + + + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -single_module linker flag" >&5 +$as_echo_n "checking for -single_module linker flag... " >&6; } +if ${lt_cv_apple_cc_single_mod+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_apple_cc_single_mod=no + if test -z "${LT_MULTI_MODULE}"; then + # By default we will add the -single_module flag. You can override + # by either setting the environment variable LT_MULTI_MODULE + # non-empty at configure time, or by adding -multi_module to the + # link flags. + rm -rf libconftest.dylib* + echo "int foo(void){return 1;}" > conftest.c + echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \ +-dynamiclib -Wl,-single_module conftest.c" >&5 + $LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \ + -dynamiclib -Wl,-single_module conftest.c 2>conftest.err + _lt_result=$? + # If there is a non-empty error log, and "single_module" + # appears in it, assume the flag caused a linker warning + if test -s conftest.err && $GREP single_module conftest.err; then + cat conftest.err >&5 + # Otherwise, if the output was created with a 0 exit code from + # the compiler, it worked. + elif test -f libconftest.dylib && test $_lt_result -eq 0; then + lt_cv_apple_cc_single_mod=yes + else + cat conftest.err >&5 + fi + rm -rf libconftest.dylib* + rm -f conftest.* + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_apple_cc_single_mod" >&5 +$as_echo "$lt_cv_apple_cc_single_mod" >&6; } + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -exported_symbols_list linker flag" >&5 +$as_echo_n "checking for -exported_symbols_list linker flag... " >&6; } +if ${lt_cv_ld_exported_symbols_list+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_ld_exported_symbols_list=no + save_LDFLAGS=$LDFLAGS + echo "_main" > conftest.sym + LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + lt_cv_ld_exported_symbols_list=yes +else + lt_cv_ld_exported_symbols_list=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + LDFLAGS="$save_LDFLAGS" + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5 +$as_echo "$lt_cv_ld_exported_symbols_list" >&6; } + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -force_load linker flag" >&5 +$as_echo_n "checking for -force_load linker flag... " >&6; } +if ${lt_cv_ld_force_load+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_ld_force_load=no + cat > conftest.c << _LT_EOF +int forced_loaded() { return 2;} +_LT_EOF + echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&5 + $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&5 + echo "$AR cru libconftest.a conftest.o" >&5 + $AR cru libconftest.a conftest.o 2>&5 + echo "$RANLIB libconftest.a" >&5 + $RANLIB libconftest.a 2>&5 + cat > conftest.c << _LT_EOF +int main() { return 0;} +_LT_EOF + echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&5 + $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err + _lt_result=$? + if test -s conftest.err && $GREP force_load conftest.err; then + cat conftest.err >&5 + elif test -f conftest && test $_lt_result -eq 0 && $GREP forced_load conftest >/dev/null 2>&1 ; then + lt_cv_ld_force_load=yes + else + cat conftest.err >&5 + fi + rm -f conftest.err libconftest.a conftest conftest.c + rm -rf conftest.dSYM + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_force_load" >&5 +$as_echo "$lt_cv_ld_force_load" >&6; } + case $host_os in + rhapsody* | darwin1.[012]) + _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;; + darwin1.*) + _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;; + darwin*) # darwin 5.x on + # if running on 10.5 or later, the deployment target defaults + # to the OS version, if on x86, and 10.4, the deployment + # target defaults to 10.4. Don't you love it? + case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in + 10.0,*86*-darwin8*|10.0,*-darwin[91]*) + _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;; + 10.[012]*) + _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;; + 10.*) + _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;; + esac + ;; + esac + if test "$lt_cv_apple_cc_single_mod" = "yes"; then + _lt_dar_single_mod='$single_module' + fi + if test "$lt_cv_ld_exported_symbols_list" = "yes"; then + _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym' + else + _lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}' + fi + if test "$DSYMUTIL" != ":" && test "$lt_cv_ld_force_load" = "no"; then + _lt_dsymutil='~$DSYMUTIL $lib || :' + else + _lt_dsymutil= + fi + ;; + esac + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 +$as_echo_n "checking how to run the C preprocessor... " >&6; } +# On Suns, sometimes $CPP names a directory. +if test -n "$CPP" && test -d "$CPP"; then + CPP= +fi +if test -z "$CPP"; then + if ${ac_cv_prog_CPP+:} false; then : + $as_echo_n "(cached) " >&6 +else + # Double quotes because CPP needs to be expanded + for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" + do + ac_preproc_ok=false +for ac_c_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + break +fi + + done + ac_cv_prog_CPP=$CPP + +fi + CPP=$ac_cv_prog_CPP +else + ac_cv_prog_CPP=$CPP +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 +$as_echo "$CPP" >&6; } +ac_preproc_ok=false +for ac_c_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + +else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "C preprocessor \"$CPP\" fails sanity check +See \`config.log' for more details" "$LINENO" 5; } +fi + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 +$as_echo_n "checking for ANSI C header files... " >&6; } +if ${ac_cv_header_stdc+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +#include +#include + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_header_stdc=yes +else + ac_cv_header_stdc=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + +if test $ac_cv_header_stdc = yes; then + # SunOS 4.x string.h does not declare mem*, contrary to ANSI. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + +_ACEOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + $EGREP "memchr" >/dev/null 2>&1; then : + +else + ac_cv_header_stdc=no +fi +rm -f conftest* + +fi + +if test $ac_cv_header_stdc = yes; then + # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + +_ACEOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + $EGREP "free" >/dev/null 2>&1; then : + +else + ac_cv_header_stdc=no +fi +rm -f conftest* + +fi + +if test $ac_cv_header_stdc = yes; then + # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. + if test "$cross_compiling" = yes; then : + : +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +#if ((' ' & 0x0FF) == 0x020) +# define ISLOWER(c) ('a' <= (c) && (c) <= 'z') +# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) +#else +# define ISLOWER(c) \ + (('a' <= (c) && (c) <= 'i') \ + || ('j' <= (c) && (c) <= 'r') \ + || ('s' <= (c) && (c) <= 'z')) +# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) +#endif + +#define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) +int +main () +{ + int i; + for (i = 0; i < 256; i++) + if (XOR (islower (i), ISLOWER (i)) + || toupper (i) != TOUPPER (i)) + return 2; + return 0; +} +_ACEOF +if ac_fn_c_try_run "$LINENO"; then : + +else + ac_cv_header_stdc=no +fi +rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ + conftest.$ac_objext conftest.beam conftest.$ac_ext +fi + +fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 +$as_echo "$ac_cv_header_stdc" >&6; } +if test $ac_cv_header_stdc = yes; then + +$as_echo "#define STDC_HEADERS 1" >>confdefs.h + +fi + +# On IRIX 5.3, sys/types and inttypes.h are conflicting. +for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ + inttypes.h stdint.h unistd.h +do : + as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` +ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default +" +if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : + cat >>confdefs.h <<_ACEOF +#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 +_ACEOF + +fi + +done + + +for ac_header in dlfcn.h +do : + ac_fn_c_check_header_compile "$LINENO" "dlfcn.h" "ac_cv_header_dlfcn_h" "$ac_includes_default +" +if test "x$ac_cv_header_dlfcn_h" = xyes; then : + cat >>confdefs.h <<_ACEOF +#define HAVE_DLFCN_H 1 +_ACEOF + +fi + +done + + + + +func_stripname_cnf () +{ + case ${2} in + .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;; + *) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;; + esac +} # func_stripname_cnf + + + + + +# Set options + + + + enable_dlopen=no + + + enable_win32_dll=no + + + # Check whether --enable-shared was given. +if test "${enable_shared+set}" = set; then : + enableval=$enable_shared; p=${PACKAGE-default} + case $enableval in + yes) enable_shared=yes ;; + no) enable_shared=no ;; + *) + enable_shared=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_shared=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac +else + enable_shared=yes +fi + + + + + + + + + + + +# Check whether --with-pic was given. +if test "${with_pic+set}" = set; then : + withval=$with_pic; lt_p=${PACKAGE-default} + case $withval in + yes|no) pic_mode=$withval ;; + *) + pic_mode=default + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for lt_pkg in $withval; do + IFS="$lt_save_ifs" + if test "X$lt_pkg" = "X$lt_p"; then + pic_mode=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac +else + pic_mode=default +fi + + +test -z "$pic_mode" && pic_mode=default + + + + + + + + # Check whether --enable-fast-install was given. +if test "${enable_fast_install+set}" = set; then : + enableval=$enable_fast_install; p=${PACKAGE-default} + case $enableval in + yes) enable_fast_install=yes ;; + no) enable_fast_install=no ;; + *) + enable_fast_install=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_fast_install=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac +else + enable_fast_install=yes +fi + + + + + + + + + + + +# This can be used to rebuild libtool when needed +LIBTOOL_DEPS="$ltmain" + +# Always use our own libtool. +LIBTOOL='$(SHELL) $(top_builddir)/libtool' + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +test -z "$LN_S" && LN_S="ln -s" + + + + + + + + + + + + + + +if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for objdir" >&5 +$as_echo_n "checking for objdir... " >&6; } +if ${lt_cv_objdir+:} false; then : + $as_echo_n "(cached) " >&6 +else + rm -f .libs 2>/dev/null +mkdir .libs 2>/dev/null +if test -d .libs; then + lt_cv_objdir=.libs +else + # MS-DOS does not allow filenames that begin with a dot. + lt_cv_objdir=_libs +fi +rmdir .libs 2>/dev/null +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir" >&5 +$as_echo "$lt_cv_objdir" >&6; } +objdir=$lt_cv_objdir + + + + + +cat >>confdefs.h <<_ACEOF +#define LT_OBJDIR "$lt_cv_objdir/" +_ACEOF + + + + +case $host_os in +aix3*) + # AIX sometimes has problems with the GCC collect2 program. For some + # reason, if we set the COLLECT_NAMES environment variable, the problems + # vanish in a puff of smoke. + if test "X${COLLECT_NAMES+set}" != Xset; then + COLLECT_NAMES= + export COLLECT_NAMES + fi + ;; +esac + +# Global variables: +ofile=libtool +can_build_shared=yes + +# All known linkers require a `.a' archive for static linking (except MSVC, +# which needs '.lib'). +libext=a + +with_gnu_ld="$lt_cv_prog_gnu_ld" + +old_CC="$CC" +old_CFLAGS="$CFLAGS" + +# Set sane defaults for various variables +test -z "$CC" && CC=cc +test -z "$LTCC" && LTCC=$CC +test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS +test -z "$LD" && LD=ld +test -z "$ac_objext" && ac_objext=o + +for cc_temp in $compiler""; do + case $cc_temp in + compile | *[\\/]compile | ccache | *[\\/]ccache ) ;; + distcc | *[\\/]distcc | purify | *[\\/]purify ) ;; + \-*) ;; + *) break;; + esac +done +cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` + + +# Only perform the check for file, if the check method requires it +test -z "$MAGIC_CMD" && MAGIC_CMD=file +case $deplibs_check_method in +file_magic*) + if test "$file_magic_cmd" = '$MAGIC_CMD'; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ac_tool_prefix}file" >&5 +$as_echo_n "checking for ${ac_tool_prefix}file... " >&6; } +if ${lt_cv_path_MAGIC_CMD+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $MAGIC_CMD in +[\\/*] | ?:[\\/]*) + lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. + ;; +*) + lt_save_MAGIC_CMD="$MAGIC_CMD" + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + ac_dummy="/usr/bin$PATH_SEPARATOR$PATH" + for ac_dir in $ac_dummy; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/${ac_tool_prefix}file; then + lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file" + if test -n "$file_magic_test_file"; then + case $deplibs_check_method in + "file_magic "*) + file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"` + MAGIC_CMD="$lt_cv_path_MAGIC_CMD" + if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | + $EGREP "$file_magic_regex" > /dev/null; then + : + else + cat <<_LT_EOF 1>&2 + +*** Warning: the command libtool uses to detect shared libraries, +*** $file_magic_cmd, produces output that libtool cannot recognize. +*** The result is that libtool may fail to recognize shared libraries +*** as such. This will affect the creation of libtool libraries that +*** depend on shared libraries, but programs linked with such libtool +*** libraries will work regardless of this problem. Nevertheless, you +*** may want to report the problem to your system manager and/or to +*** bug-libtool@gnu.org + +_LT_EOF + fi ;; + esac + fi + break + fi + done + IFS="$lt_save_ifs" + MAGIC_CMD="$lt_save_MAGIC_CMD" + ;; +esac +fi + +MAGIC_CMD="$lt_cv_path_MAGIC_CMD" +if test -n "$MAGIC_CMD"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5 +$as_echo "$MAGIC_CMD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + + +if test -z "$lt_cv_path_MAGIC_CMD"; then + if test -n "$ac_tool_prefix"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for file" >&5 +$as_echo_n "checking for file... " >&6; } +if ${lt_cv_path_MAGIC_CMD+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $MAGIC_CMD in +[\\/*] | ?:[\\/]*) + lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. + ;; +*) + lt_save_MAGIC_CMD="$MAGIC_CMD" + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + ac_dummy="/usr/bin$PATH_SEPARATOR$PATH" + for ac_dir in $ac_dummy; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/file; then + lt_cv_path_MAGIC_CMD="$ac_dir/file" + if test -n "$file_magic_test_file"; then + case $deplibs_check_method in + "file_magic "*) + file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"` + MAGIC_CMD="$lt_cv_path_MAGIC_CMD" + if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | + $EGREP "$file_magic_regex" > /dev/null; then + : + else + cat <<_LT_EOF 1>&2 + +*** Warning: the command libtool uses to detect shared libraries, +*** $file_magic_cmd, produces output that libtool cannot recognize. +*** The result is that libtool may fail to recognize shared libraries +*** as such. This will affect the creation of libtool libraries that +*** depend on shared libraries, but programs linked with such libtool +*** libraries will work regardless of this problem. Nevertheless, you +*** may want to report the problem to your system manager and/or to +*** bug-libtool@gnu.org + +_LT_EOF + fi ;; + esac + fi + break + fi + done + IFS="$lt_save_ifs" + MAGIC_CMD="$lt_save_MAGIC_CMD" + ;; +esac +fi + +MAGIC_CMD="$lt_cv_path_MAGIC_CMD" +if test -n "$MAGIC_CMD"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5 +$as_echo "$MAGIC_CMD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + MAGIC_CMD=: + fi +fi + + fi + ;; +esac + +# Use C for the default configuration in the libtool script + +lt_save_CC="$CC" +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + +# Source file extension for C test sources. +ac_ext=c + +# Object file extension for compiled C test sources. +objext=o +objext=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code="int some_variable = 0;" + +# Code to be used in simple link tests +lt_simple_link_test_code='int main(){return(0);}' + + + + + + + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# If no C compiler flags were specified, use CFLAGS. +LTCFLAGS=${LTCFLAGS-"$CFLAGS"} + +# Allow CC to be a program name with arguments. +compiler=$CC + +# Save the default compiler, since it gets overwritten when the other +# tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP. +compiler_DEFAULT=$CC + +# save warnings/boilerplate of simple test code +ac_outfile=conftest.$ac_objext +echo "$lt_simple_compile_test_code" >conftest.$ac_ext +eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err +_lt_compiler_boilerplate=`cat conftest.err` +$RM conftest* + +ac_outfile=conftest.$ac_objext +echo "$lt_simple_link_test_code" >conftest.$ac_ext +eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err +_lt_linker_boilerplate=`cat conftest.err` +$RM -r conftest* + + +## CAVEAT EMPTOR: +## There is no encapsulation within the following macros, do not change +## the running order or otherwise move them around unless you know exactly +## what you are doing... +if test -n "$compiler"; then + +lt_prog_compiler_no_builtin_flag= + +if test "$GCC" = yes; then + case $cc_basename in + nvcc*) + lt_prog_compiler_no_builtin_flag=' -Xcompiler -fno-builtin' ;; + *) + lt_prog_compiler_no_builtin_flag=' -fno-builtin' ;; + esac + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions" >&5 +$as_echo_n "checking if $compiler supports -fno-rtti -fno-exceptions... " >&6; } +if ${lt_cv_prog_compiler_rtti_exceptions+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_rtti_exceptions=no + ac_outfile=conftest.$ac_objext + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="-fno-rtti -fno-exceptions" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings other than the usual output. + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then + lt_cv_prog_compiler_rtti_exceptions=yes + fi + fi + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5 +$as_echo "$lt_cv_prog_compiler_rtti_exceptions" >&6; } + +if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then + lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions" +else + : +fi + +fi + + + + + + + lt_prog_compiler_wl= +lt_prog_compiler_pic= +lt_prog_compiler_static= + + + if test "$GCC" = yes; then + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_static='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static='-Bstatic' + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + lt_prog_compiler_pic='-fPIC' + ;; + m68k) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the `-m68020' flag to GCC prevents building anything better, + # like `-m68040'. + lt_prog_compiler_pic='-m68020 -resident32 -malways-restore-a4' + ;; + esac + ;; + + beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + + mingw* | cygwin* | pw32* | os2* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + # Although the cygwin gcc ignores -fPIC, still need this for old-style + # (--disable-auto-import) libraries + lt_prog_compiler_pic='-DDLL_EXPORT' + ;; + + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + lt_prog_compiler_pic='-fno-common' + ;; + + haiku*) + # PIC is the default for Haiku. + # The "-static" flag exists, but is broken. + lt_prog_compiler_static= + ;; + + hpux*) + # PIC is the default for 64-bit PA HP-UX, but not for 32-bit + # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag + # sets the default TLS model and affects inlining. + case $host_cpu in + hppa*64*) + # +Z the default + ;; + *) + lt_prog_compiler_pic='-fPIC' + ;; + esac + ;; + + interix[3-9]*) + # Interix 3.x gcc -fpic/-fPIC options generate broken code. + # Instead, we relocate shared libraries at runtime. + ;; + + msdosdjgpp*) + # Just because we use GCC doesn't mean we suddenly get shared libraries + # on systems that don't support them. + lt_prog_compiler_can_build_shared=no + enable_shared=no + ;; + + *nto* | *qnx*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + lt_prog_compiler_pic='-fPIC -shared' + ;; + + sysv4*MP*) + if test -d /usr/nec; then + lt_prog_compiler_pic=-Kconform_pic + fi + ;; + + *) + lt_prog_compiler_pic='-fPIC' + ;; + esac + + case $cc_basename in + nvcc*) # Cuda Compiler Driver 2.2 + lt_prog_compiler_wl='-Xlinker ' + if test -n "$lt_prog_compiler_pic"; then + lt_prog_compiler_pic="-Xcompiler $lt_prog_compiler_pic" + fi + ;; + esac + else + # PORTME Check for flag to pass linker flags through the system compiler. + case $host_os in + aix*) + lt_prog_compiler_wl='-Wl,' + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static='-Bstatic' + else + lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp' + fi + ;; + + mingw* | cygwin* | pw32* | os2* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + lt_prog_compiler_pic='-DDLL_EXPORT' + ;; + + hpux9* | hpux10* | hpux11*) + lt_prog_compiler_wl='-Wl,' + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case $host_cpu in + hppa*64*|ia64*) + # +Z the default + ;; + *) + lt_prog_compiler_pic='+Z' + ;; + esac + # Is there a better lt_prog_compiler_static that works with the bundled CC? + lt_prog_compiler_static='${wl}-a ${wl}archive' + ;; + + irix5* | irix6* | nonstopux*) + lt_prog_compiler_wl='-Wl,' + # PIC (with -KPIC) is the default. + lt_prog_compiler_static='-non_shared' + ;; + + linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + case $cc_basename in + # old Intel for x86_64 which still supported -KPIC. + ecc*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-static' + ;; + # icc used to be incompatible with GCC. + # ICC 10 doesn't accept -KPIC any more. + icc* | ifort*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-fPIC' + lt_prog_compiler_static='-static' + ;; + # Lahey Fortran 8.1. + lf95*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='--shared' + lt_prog_compiler_static='--static' + ;; + nagfor*) + # NAG Fortran compiler + lt_prog_compiler_wl='-Wl,-Wl,,' + lt_prog_compiler_pic='-PIC' + lt_prog_compiler_static='-Bstatic' + ;; + pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*) + # Portland Group compilers (*not* the Pentium gcc compiler, + # which looks to be a dead project) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-fpic' + lt_prog_compiler_static='-Bstatic' + ;; + ccc*) + lt_prog_compiler_wl='-Wl,' + # All Alpha code is PIC. + lt_prog_compiler_static='-non_shared' + ;; + xl* | bgxl* | bgf* | mpixl*) + # IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-qpic' + lt_prog_compiler_static='-qstaticlink' + ;; + *) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ Ceres\ Fortran* | *Sun*Fortran*\ [1-7].* | *Sun*Fortran*\ 8.[0-3]*) + # Sun Fortran 8.3 passes all unrecognized flags to the linker + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + lt_prog_compiler_wl='' + ;; + *Sun\ F* | *Sun*Fortran*) + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + lt_prog_compiler_wl='-Qoption ld ' + ;; + *Sun\ C*) + # Sun C 5.9 + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + lt_prog_compiler_wl='-Wl,' + ;; + *Intel*\ [CF]*Compiler*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-fPIC' + lt_prog_compiler_static='-static' + ;; + *Portland\ Group*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-fpic' + lt_prog_compiler_static='-Bstatic' + ;; + esac + ;; + esac + ;; + + newsos6) + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + ;; + + *nto* | *qnx*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + lt_prog_compiler_pic='-fPIC -shared' + ;; + + osf3* | osf4* | osf5*) + lt_prog_compiler_wl='-Wl,' + # All OSF/1 code is PIC. + lt_prog_compiler_static='-non_shared' + ;; + + rdos*) + lt_prog_compiler_static='-non_shared' + ;; + + solaris*) + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + case $cc_basename in + f77* | f90* | f95* | sunf77* | sunf90* | sunf95*) + lt_prog_compiler_wl='-Qoption ld ';; + *) + lt_prog_compiler_wl='-Wl,';; + esac + ;; + + sunos4*) + lt_prog_compiler_wl='-Qoption ld ' + lt_prog_compiler_pic='-PIC' + lt_prog_compiler_static='-Bstatic' + ;; + + sysv4 | sysv4.2uw2* | sysv4.3*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + ;; + + sysv4*MP*) + if test -d /usr/nec ;then + lt_prog_compiler_pic='-Kconform_pic' + lt_prog_compiler_static='-Bstatic' + fi + ;; + + sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + ;; + + unicos*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_can_build_shared=no + ;; + + uts4*) + lt_prog_compiler_pic='-pic' + lt_prog_compiler_static='-Bstatic' + ;; + + *) + lt_prog_compiler_can_build_shared=no + ;; + esac + fi + +case $host_os in + # For platforms which do not support PIC, -DPIC is meaningless: + *djgpp*) + lt_prog_compiler_pic= + ;; + *) + lt_prog_compiler_pic="$lt_prog_compiler_pic -DPIC" + ;; +esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 +$as_echo_n "checking for $compiler option to produce PIC... " >&6; } +if ${lt_cv_prog_compiler_pic+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_pic=$lt_prog_compiler_pic +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic" >&5 +$as_echo "$lt_cv_prog_compiler_pic" >&6; } +lt_prog_compiler_pic=$lt_cv_prog_compiler_pic + +# +# Check to make sure the PIC flag actually works. +# +if test -n "$lt_prog_compiler_pic"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5 +$as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic works... " >&6; } +if ${lt_cv_prog_compiler_pic_works+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_pic_works=no + ac_outfile=conftest.$ac_objext + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="$lt_prog_compiler_pic -DPIC" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings other than the usual output. + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then + lt_cv_prog_compiler_pic_works=yes + fi + fi + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5 +$as_echo "$lt_cv_prog_compiler_pic_works" >&6; } + +if test x"$lt_cv_prog_compiler_pic_works" = xyes; then + case $lt_prog_compiler_pic in + "" | " "*) ;; + *) lt_prog_compiler_pic=" $lt_prog_compiler_pic" ;; + esac +else + lt_prog_compiler_pic= + lt_prog_compiler_can_build_shared=no +fi + +fi + + + + + + + + + + + +# +# Check to make sure the static flag actually works. +# +wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\" +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5 +$as_echo_n "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; } +if ${lt_cv_prog_compiler_static_works+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_static_works=no + save_LDFLAGS="$LDFLAGS" + LDFLAGS="$LDFLAGS $lt_tmp_static_flag" + echo "$lt_simple_link_test_code" > conftest.$ac_ext + if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then + # The linker can only warn and ignore the option if not recognized + # So say no if there are warnings + if test -s conftest.err; then + # Append any errors to the config.log. + cat conftest.err 1>&5 + $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if diff conftest.exp conftest.er2 >/dev/null; then + lt_cv_prog_compiler_static_works=yes + fi + else + lt_cv_prog_compiler_static_works=yes + fi + fi + $RM -r conftest* + LDFLAGS="$save_LDFLAGS" + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5 +$as_echo "$lt_cv_prog_compiler_static_works" >&6; } + +if test x"$lt_cv_prog_compiler_static_works" = xyes; then + : +else + lt_prog_compiler_static= +fi + + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 +$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } +if ${lt_cv_prog_compiler_c_o+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_c_o=no + $RM -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp + $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 + if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then + lt_cv_prog_compiler_c_o=yes + fi + fi + chmod u+w . 2>&5 + $RM conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files + $RM out/* && rmdir out + cd .. + $RM -r conftest + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5 +$as_echo "$lt_cv_prog_compiler_c_o" >&6; } + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 +$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } +if ${lt_cv_prog_compiler_c_o+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_c_o=no + $RM -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp + $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 + if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then + lt_cv_prog_compiler_c_o=yes + fi + fi + chmod u+w . 2>&5 + $RM conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files + $RM out/* && rmdir out + cd .. + $RM -r conftest + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5 +$as_echo "$lt_cv_prog_compiler_c_o" >&6; } + + + + +hard_links="nottested" +if test "$lt_cv_prog_compiler_c_o" = no && test "$need_locks" != no; then + # do not overwrite the value of need_locks provided by the user + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 +$as_echo_n "checking if we can lock with hard links... " >&6; } + hard_links=yes + $RM conftest* + ln conftest.a conftest.b 2>/dev/null && hard_links=no + touch conftest.a + ln conftest.a conftest.b 2>&5 || hard_links=no + ln conftest.a conftest.b 2>/dev/null && hard_links=no + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 +$as_echo "$hard_links" >&6; } + if test "$hard_links" = no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5 +$as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;} + need_locks=warn + fi +else + need_locks=no +fi + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 +$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } + + runpath_var= + allow_undefined_flag= + always_export_symbols=no + archive_cmds= + archive_expsym_cmds= + compiler_needs_object=no + enable_shared_with_static_runtimes=no + export_dynamic_flag_spec= + export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + hardcode_automatic=no + hardcode_direct=no + hardcode_direct_absolute=no + hardcode_libdir_flag_spec= + hardcode_libdir_separator= + hardcode_minus_L=no + hardcode_shlibpath_var=unsupported + inherit_rpath=no + link_all_deplibs=unknown + module_cmds= + module_expsym_cmds= + old_archive_from_new_cmds= + old_archive_from_expsyms_cmds= + thread_safe_flag_spec= + whole_archive_flag_spec= + # include_expsyms should be a list of space-separated symbols to be *always* + # included in the symbol list + include_expsyms= + # exclude_expsyms can be an extended regexp of symbols to exclude + # it will be wrapped by ` (' and `)$', so one must not match beginning or + # end of line. Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc', + # as well as any symbol that contains `d'. + exclude_expsyms='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*' + # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out + # platforms (ab)use it in PIC code, but their linkers get confused if + # the symbol is explicitly referenced. Since portable code cannot + # rely on this symbol name, it's probably fine to never include it in + # preloaded symbol tables. + # Exclude shared library initialization/finalization symbols. + extract_expsyms_cmds= + + case $host_os in + cygwin* | mingw* | pw32* | cegcc*) + # FIXME: the MSVC++ port hasn't been tested in a loooong time + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + if test "$GCC" != yes; then + with_gnu_ld=no + fi + ;; + interix*) + # we just hope/assume this is gcc and not c89 (= MSVC++) + with_gnu_ld=yes + ;; + openbsd*) + with_gnu_ld=no + ;; + linux* | k*bsd*-gnu | gnu*) + link_all_deplibs=no + ;; + esac + + ld_shlibs=yes + + # On some targets, GNU ld is compatible enough with the native linker + # that we're better off using the native interface for both. + lt_use_gnu_ld_interface=no + if test "$with_gnu_ld" = yes; then + case $host_os in + aix*) + # The AIX port of GNU ld has always aspired to compatibility + # with the native linker. However, as the warning in the GNU ld + # block says, versions before 2.19.5* couldn't really create working + # shared libraries, regardless of the interface used. + case `$LD -v 2>&1` in + *\ \(GNU\ Binutils\)\ 2.19.5*) ;; + *\ \(GNU\ Binutils\)\ 2.[2-9]*) ;; + *\ \(GNU\ Binutils\)\ [3-9]*) ;; + *) + lt_use_gnu_ld_interface=yes + ;; + esac + ;; + *) + lt_use_gnu_ld_interface=yes + ;; + esac + fi + + if test "$lt_use_gnu_ld_interface" = yes; then + # If archive_cmds runs LD, not CC, wlarc should be empty + wlarc='${wl}' + + # Set some defaults for GNU ld with shared library support. These + # are reset later if shared libraries are not supported. Putting them + # here allows them to be overridden if necessary. + runpath_var=LD_RUN_PATH + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + export_dynamic_flag_spec='${wl}--export-dynamic' + # ancient GNU ld didn't support --whole-archive et. al. + if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then + whole_archive_flag_spec="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + else + whole_archive_flag_spec= + fi + supports_anon_versioning=no + case `$LD -v 2>&1` in + *GNU\ gold*) supports_anon_versioning=yes ;; + *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11 + *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ... + *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ... + *\ 2.11.*) ;; # other 2.11 versions + *) supports_anon_versioning=yes ;; + esac + + # See if GNU ld supports shared libraries. + case $host_os in + aix[3-9]*) + # On AIX/PPC, the GNU linker is very broken + if test "$host_cpu" != ia64; then + ld_shlibs=no + cat <<_LT_EOF 1>&2 + +*** Warning: the GNU linker, at least up to release 2.19, is reported +*** to be unable to reliably create shared libraries on AIX. +*** Therefore, libtool is disabling shared libraries support. If you +*** really care for shared libraries, you may want to install binutils +*** 2.20 or above, or modify your PATH so that a non-GNU linker is found. +*** You will then need to restart the configuration process. + +_LT_EOF + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='' + ;; + m68k) + archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + hardcode_libdir_flag_spec='-L$libdir' + hardcode_minus_L=yes + ;; + esac + ;; + + beos*) + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + allow_undefined_flag=unsupported + # Joseph Beckenbach says some releases of gcc + # support --undefined. This deserves some investigation. FIXME + archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + else + ld_shlibs=no + fi + ;; + + cygwin* | mingw* | pw32* | cegcc*) + # _LT_TAGVAR(hardcode_libdir_flag_spec, ) is actually meaningless, + # as there is no search path for DLLs. + hardcode_libdir_flag_spec='-L$libdir' + export_dynamic_flag_spec='${wl}--export-all-symbols' + allow_undefined_flag=unsupported + always_export_symbols=no + enable_shared_with_static_runtimes=yes + export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1 DATA/;s/^.*[ ]__nm__\([^ ]*\)[ ][^ ]*/\1 DATA/;/^I[ ]/d;/^[AITW][ ]/s/.* //'\'' | sort | uniq > $export_symbols' + exclude_expsyms='[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname' + + if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + # If the export-symbols file already is a .def file (1st line + # is EXPORTS), use it as is; otherwise, prepend... + archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + else + ld_shlibs=no + fi + ;; + + haiku*) + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + link_all_deplibs=yes + ;; + + interix[3-9]*) + hardcode_direct=no + hardcode_shlibpath_var=no + hardcode_libdir_flag_spec='${wl}-rpath,$libdir' + export_dynamic_flag_spec='${wl}-E' + # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc. + # Instead, shared libraries are loaded at an image base (0x10000000 by + # default) and relocated if they conflict, which is a slow very memory + # consuming and fragmenting process. To avoid this, we pick a random, + # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link + # time. Moving up from 0x10000000 also allows more sbrk(2) space. + archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + archive_expsym_cmds='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + ;; + + gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu) + tmp_diet=no + if test "$host_os" = linux-dietlibc; then + case $cc_basename in + diet\ *) tmp_diet=yes;; # linux-dietlibc with static linking (!diet-dyn) + esac + fi + if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \ + && test "$tmp_diet" = no + then + tmp_addflag=' $pic_flag' + tmp_sharedflag='-shared' + case $cc_basename,$host_cpu in + pgcc*) # Portland Group C compiler + whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + tmp_addflag=' $pic_flag' + ;; + pgf77* | pgf90* | pgf95* | pgfortran*) + # Portland Group f77 and f90 compilers + whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + tmp_addflag=' $pic_flag -Mnomain' ;; + ecc*,ia64* | icc*,ia64*) # Intel C compiler on ia64 + tmp_addflag=' -i_dynamic' ;; + efc*,ia64* | ifort*,ia64*) # Intel Fortran compiler on ia64 + tmp_addflag=' -i_dynamic -nofor_main' ;; + ifc* | ifort*) # Intel Fortran compiler + tmp_addflag=' -nofor_main' ;; + lf95*) # Lahey Fortran 8.1 + whole_archive_flag_spec= + tmp_sharedflag='--shared' ;; + xl[cC]* | bgxl[cC]* | mpixl[cC]*) # IBM XL C 8.0 on PPC (deal with xlf below) + tmp_sharedflag='-qmkshrobj' + tmp_addflag= ;; + nvcc*) # Cuda Compiler Driver 2.2 + whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + compiler_needs_object=yes + ;; + esac + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) # Sun C 5.9 + whole_archive_flag_spec='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + compiler_needs_object=yes + tmp_sharedflag='-G' ;; + *Sun\ F*) # Sun Fortran 8.3 + tmp_sharedflag='-G' ;; + esac + archive_cmds='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + + if test "x$supports_anon_versioning" = xyes; then + archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~ + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' + fi + + case $cc_basename in + xlf* | bgf* | bgxlf* | mpixlf*) + # IBM XL Fortran 10.1 on PPC cannot create shared libs itself + whole_archive_flag_spec='--whole-archive$convenience --no-whole-archive' + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + archive_cmds='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib' + if test "x$supports_anon_versioning" = xyes; then + archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~ + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib' + fi + ;; + esac + else + ld_shlibs=no + fi + ;; + + netbsd* | netbsdelf*-gnu) + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib' + wlarc= + else + archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + fi + ;; + + solaris*) + if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then + ld_shlibs=no + cat <<_LT_EOF 1>&2 + +*** Warning: The releases 2.8.* of the GNU linker cannot reliably +*** create shared libraries on Solaris systems. Therefore, libtool +*** is disabling shared libraries support. We urge you to upgrade GNU +*** binutils to release 2.9.1 or newer. Another option is to modify +*** your PATH or compiler configuration so that the native linker is +*** used, and then restart. + +_LT_EOF + elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + ld_shlibs=no + fi + ;; + + sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*) + case `$LD -v 2>&1` in + *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*) + ld_shlibs=no + cat <<_LT_EOF 1>&2 + +*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not +*** reliably create shared libraries on SCO systems. Therefore, libtool +*** is disabling shared libraries support. We urge you to upgrade GNU +*** binutils to release 2.16.91.0.3 or newer. Another option is to modify +*** your PATH or compiler configuration so that the native linker is +*** used, and then restart. + +_LT_EOF + ;; + *) + # For security reasons, it is highly recommended that you always + # use absolute paths for naming shared libraries, and exclude the + # DT_RUNPATH tag from executables and libraries. But doing so + # requires that you compile everything twice, which is a pain. + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + ld_shlibs=no + fi + ;; + esac + ;; + + sunos4*) + archive_cmds='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags' + wlarc= + hardcode_direct=yes + hardcode_shlibpath_var=no + ;; + + *) + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + ld_shlibs=no + fi + ;; + esac + + if test "$ld_shlibs" = no; then + runpath_var= + hardcode_libdir_flag_spec= + export_dynamic_flag_spec= + whole_archive_flag_spec= + fi + else + # PORTME fill in a description of your system's linker (not GNU ld) + case $host_os in + aix3*) + allow_undefined_flag=unsupported + always_export_symbols=yes + archive_expsym_cmds='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname' + # Note: this linker hardcodes the directories in LIBPATH if there + # are no directories specified by -L. + hardcode_minus_L=yes + if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then + # Neither direct hardcoding nor static linking is supported with a + # broken collect2. + hardcode_direct=unsupported + fi + ;; + + aix[4-9]*) + if test "$host_cpu" = ia64; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag="" + else + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to AIX nm, but means don't demangle with GNU nm + # Also, AIX nm treats weak defined symbols like other global + # defined symbols, whereas GNU nm marks them as "W". + if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then + export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + else + export_symbols_cmds='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + fi + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # need to do runtime linking. + case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*) + for ld_flag in $LDFLAGS; do + if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then + aix_use_runtimelinking=yes + break + fi + done + ;; + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + archive_cmds='' + hardcode_direct=yes + hardcode_direct_absolute=yes + hardcode_libdir_separator=':' + link_all_deplibs=yes + file_list_spec='${wl}-f,' + + if test "$GCC" = yes; then + case $host_os in aix4.[012]|aix4.[012].*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`${CC} -print-prog-name=collect2` + if test -f "$collect2name" && + strings "$collect2name" | $GREP resolve_lib_name >/dev/null + then + # We have reworked collect2 + : + else + # We have old collect2 + hardcode_direct=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + hardcode_minus_L=yes + hardcode_libdir_flag_spec='-L$libdir' + hardcode_libdir_separator= + fi + ;; + esac + shared_flag='-shared' + if test "$aix_use_runtimelinking" = yes; then + shared_flag="$shared_flag "'${wl}-G' + fi + link_all_deplibs=no + else + # not using gcc + if test "$host_cpu" = ia64; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test "$aix_use_runtimelinking" = yes; then + shared_flag='${wl}-G' + else + shared_flag='${wl}-bM:SRE' + fi + fi + fi + + export_dynamic_flag_spec='${wl}-bexpall' + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to export. + always_export_symbols=yes + if test "$aix_use_runtimelinking" = yes; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + allow_undefined_flag='-berok' + # Determine the default libpath from the value encoded in an + # empty executable. + if test "${lt_cv_aix_libpath+set}" = set; then + aix_libpath=$lt_cv_aix_libpath +else + if ${lt_cv_aix_libpath_+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + + lt_aix_libpath_sed=' + /Import File Strings/,/^$/ { + /^0/ { + s/^0 *\([^ ]*\) *$/\1/ + p + } + }' + lt_cv_aix_libpath_=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + # Check for a 64-bit object if we didn't find anything. + if test -z "$lt_cv_aix_libpath_"; then + lt_cv_aix_libpath_=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + if test -z "$lt_cv_aix_libpath_"; then + lt_cv_aix_libpath_="/usr/lib:/lib" + fi + +fi + + aix_libpath=$lt_cv_aix_libpath_ +fi + + hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath" + archive_expsym_cmds='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag" + else + if test "$host_cpu" = ia64; then + hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib' + allow_undefined_flag="-z nodefs" + archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an + # empty executable. + if test "${lt_cv_aix_libpath+set}" = set; then + aix_libpath=$lt_cv_aix_libpath +else + if ${lt_cv_aix_libpath_+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + + lt_aix_libpath_sed=' + /Import File Strings/,/^$/ { + /^0/ { + s/^0 *\([^ ]*\) *$/\1/ + p + } + }' + lt_cv_aix_libpath_=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + # Check for a 64-bit object if we didn't find anything. + if test -z "$lt_cv_aix_libpath_"; then + lt_cv_aix_libpath_=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + if test -z "$lt_cv_aix_libpath_"; then + lt_cv_aix_libpath_="/usr/lib:/lib" + fi + +fi + + aix_libpath=$lt_cv_aix_libpath_ +fi + + hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + no_undefined_flag=' ${wl}-bernotok' + allow_undefined_flag=' ${wl}-berok' + if test "$with_gnu_ld" = yes; then + # We only use this code for GNU lds that support --whole-archive. + whole_archive_flag_spec='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + else + # Exported symbols can be pulled into shared objects from archives + whole_archive_flag_spec='$convenience' + fi + archive_cmds_need_lc=yes + # This is similar to how AIX traditionally builds its shared libraries. + archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + fi + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='' + ;; + m68k) + archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + hardcode_libdir_flag_spec='-L$libdir' + hardcode_minus_L=yes + ;; + esac + ;; + + bsdi[45]*) + export_dynamic_flag_spec=-rdynamic + ;; + + cygwin* | mingw* | pw32* | cegcc*) + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + # hardcode_libdir_flag_spec is actually meaningless, as there is + # no search path for DLLs. + case $cc_basename in + cl*) + # Native MSVC + hardcode_libdir_flag_spec=' ' + allow_undefined_flag=unsupported + always_export_symbols=yes + file_list_spec='@' + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + archive_cmds='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames=' + archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + sed -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp; + else + sed -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp; + fi~ + $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ + linknames=' + # The linker will not automatically build a static lib if we build a DLL. + # _LT_TAGVAR(old_archive_from_new_cmds, )='true' + enable_shared_with_static_runtimes=yes + exclude_expsyms='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*' + export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1,DATA/'\'' | $SED -e '\''/^[AITW][ ]/s/.*[ ]//'\'' | sort | uniq > $export_symbols' + # Don't use ranlib + old_postinstall_cmds='chmod 644 $oldlib' + postlink_cmds='lt_outputfile="@OUTPUT@"~ + lt_tool_outputfile="@TOOL_OUTPUT@"~ + case $lt_outputfile in + *.exe|*.EXE) ;; + *) + lt_outputfile="$lt_outputfile.exe" + lt_tool_outputfile="$lt_tool_outputfile.exe" + ;; + esac~ + if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then + $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; + $RM "$lt_outputfile.manifest"; + fi' + ;; + *) + # Assume MSVC wrapper + hardcode_libdir_flag_spec=' ' + allow_undefined_flag=unsupported + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + archive_cmds='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames=' + # The linker will automatically build a .lib file if we build a DLL. + old_archive_from_new_cmds='true' + # FIXME: Should let the user specify the lib program. + old_archive_cmds='lib -OUT:$oldlib$oldobjs$old_deplibs' + enable_shared_with_static_runtimes=yes + ;; + esac + ;; + + darwin* | rhapsody*) + + + archive_cmds_need_lc=no + hardcode_direct=no + hardcode_automatic=yes + hardcode_shlibpath_var=unsupported + if test "$lt_cv_ld_force_load" = "yes"; then + whole_archive_flag_spec='`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`' + + else + whole_archive_flag_spec='' + fi + link_all_deplibs=yes + allow_undefined_flag="$_lt_dar_allow_undefined" + case $cc_basename in + ifort*) _lt_dar_can_shared=yes ;; + *) _lt_dar_can_shared=$GCC ;; + esac + if test "$_lt_dar_can_shared" = "yes"; then + output_verbose_link_cmd=func_echo_all + archive_cmds="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}" + module_cmds="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}" + archive_expsym_cmds="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}" + module_expsym_cmds="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}" + + else + ld_shlibs=no + fi + + ;; + + dgux*) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec='-L$libdir' + hardcode_shlibpath_var=no + ;; + + # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor + # support. Future versions do this automatically, but an explicit c++rt0.o + # does not break anything, and helps significantly (at the cost of a little + # extra space). + freebsd2.2*) + archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o' + hardcode_libdir_flag_spec='-R$libdir' + hardcode_direct=yes + hardcode_shlibpath_var=no + ;; + + # Unfortunately, older versions of FreeBSD 2 do not have this feature. + freebsd2.*) + archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct=yes + hardcode_minus_L=yes + hardcode_shlibpath_var=no + ;; + + # FreeBSD 3 and greater uses gcc -shared to do shared libraries. + freebsd* | dragonfly*) + archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec='-R$libdir' + hardcode_direct=yes + hardcode_shlibpath_var=no + ;; + + hpux9*) + if test "$GCC" = yes; then + archive_cmds='$RM $output_objdir/$soname~$CC -shared $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + else + archive_cmds='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + fi + hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' + hardcode_libdir_separator=: + hardcode_direct=yes + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L=yes + export_dynamic_flag_spec='${wl}-E' + ;; + + hpux10*) + if test "$GCC" = yes && test "$with_gnu_ld" = no; then + archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' + fi + if test "$with_gnu_ld" = no; then + hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' + hardcode_libdir_separator=: + hardcode_direct=yes + hardcode_direct_absolute=yes + export_dynamic_flag_spec='${wl}-E' + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L=yes + fi + ;; + + hpux11*) + if test "$GCC" = yes && test "$with_gnu_ld" = no; then + case $host_cpu in + hppa*64*) + archive_cmds='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + ia64*) + archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + else + case $host_cpu in + hppa*64*) + archive_cmds='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + ia64*) + archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + + # Older versions of the 11.00 compiler do not understand -b yet + # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does) + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC understands -b" >&5 +$as_echo_n "checking if $CC understands -b... " >&6; } +if ${lt_cv_prog_compiler__b+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler__b=no + save_LDFLAGS="$LDFLAGS" + LDFLAGS="$LDFLAGS -b" + echo "$lt_simple_link_test_code" > conftest.$ac_ext + if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then + # The linker can only warn and ignore the option if not recognized + # So say no if there are warnings + if test -s conftest.err; then + # Append any errors to the config.log. + cat conftest.err 1>&5 + $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if diff conftest.exp conftest.er2 >/dev/null; then + lt_cv_prog_compiler__b=yes + fi + else + lt_cv_prog_compiler__b=yes + fi + fi + $RM -r conftest* + LDFLAGS="$save_LDFLAGS" + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler__b" >&5 +$as_echo "$lt_cv_prog_compiler__b" >&6; } + +if test x"$lt_cv_prog_compiler__b" = xyes; then + archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' +else + archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' +fi + + ;; + esac + fi + if test "$with_gnu_ld" = no; then + hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' + hardcode_libdir_separator=: + + case $host_cpu in + hppa*64*|ia64*) + hardcode_direct=no + hardcode_shlibpath_var=no + ;; + *) + hardcode_direct=yes + hardcode_direct_absolute=yes + export_dynamic_flag_spec='${wl}-E' + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L=yes + ;; + esac + fi + ;; + + irix5* | irix6* | nonstopux*) + if test "$GCC" = yes; then + archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + # Try to use the -exported_symbol ld option, if it does not + # work, assume that -exports_file does not work either and + # implicitly export all symbols. + # This should be the same for all languages, so no per-tag cache variable. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $host_os linker accepts -exported_symbol" >&5 +$as_echo_n "checking whether the $host_os linker accepts -exported_symbol... " >&6; } +if ${lt_cv_irix_exported_symbol+:} false; then : + $as_echo_n "(cached) " >&6 +else + save_LDFLAGS="$LDFLAGS" + LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +int foo (void) { return 0; } +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + lt_cv_irix_exported_symbol=yes +else + lt_cv_irix_exported_symbol=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + LDFLAGS="$save_LDFLAGS" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_irix_exported_symbol" >&5 +$as_echo "$lt_cv_irix_exported_symbol" >&6; } + if test "$lt_cv_irix_exported_symbol" = yes; then + archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib' + fi + else + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib' + fi + archive_cmds_need_lc='no' + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator=: + inherit_rpath=yes + link_all_deplibs=yes + ;; + + netbsd* | netbsdelf*-gnu) + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out + else + archive_cmds='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF + fi + hardcode_libdir_flag_spec='-R$libdir' + hardcode_direct=yes + hardcode_shlibpath_var=no + ;; + + newsos6) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct=yes + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator=: + hardcode_shlibpath_var=no + ;; + + *nto* | *qnx*) + ;; + + openbsd*) + if test -f /usr/libexec/ld.so; then + hardcode_direct=yes + hardcode_shlibpath_var=no + hardcode_direct_absolute=yes + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols' + hardcode_libdir_flag_spec='${wl}-rpath,$libdir' + export_dynamic_flag_spec='${wl}-E' + else + case $host_os in + openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*) + archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec='-R$libdir' + ;; + *) + archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec='${wl}-rpath,$libdir' + ;; + esac + fi + else + ld_shlibs=no + fi + ;; + + os2*) + hardcode_libdir_flag_spec='-L$libdir' + hardcode_minus_L=yes + allow_undefined_flag=unsupported + archive_cmds='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~echo DATA >> $output_objdir/$libname.def~echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def' + old_archive_from_new_cmds='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def' + ;; + + osf3*) + if test "$GCC" = yes; then + allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + allow_undefined_flag=' -expect_unresolved \*' + archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + fi + archive_cmds_need_lc='no' + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator=: + ;; + + osf4* | osf5*) # as osf3* with the addition of -msym flag + if test "$GCC" = yes; then + allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds='$CC -shared${allow_undefined_flag} $pic_flag $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + else + allow_undefined_flag=' -expect_unresolved \*' + archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + archive_expsym_cmds='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~ + $CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp' + + # Both c and cxx compiler support -rpath directly + hardcode_libdir_flag_spec='-rpath $libdir' + fi + archive_cmds_need_lc='no' + hardcode_libdir_separator=: + ;; + + solaris*) + no_undefined_flag=' -z defs' + if test "$GCC" = yes; then + wlarc='${wl}' + archive_cmds='$CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' + else + case `$CC -V 2>&1` in + *"Compilers 5.0"*) + wlarc='' + archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' + archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp' + ;; + *) + wlarc='${wl}' + archive_cmds='$CC -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' + ;; + esac + fi + hardcode_libdir_flag_spec='-R$libdir' + hardcode_shlibpath_var=no + case $host_os in + solaris2.[0-5] | solaris2.[0-5].*) ;; + *) + # The compiler driver will combine and reorder linker options, + # but understands `-z linker_flag'. GCC discards it without `$wl', + # but is careful enough not to reorder. + # Supported since Solaris 2.6 (maybe 2.5.1?) + if test "$GCC" = yes; then + whole_archive_flag_spec='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' + else + whole_archive_flag_spec='-z allextract$convenience -z defaultextract' + fi + ;; + esac + link_all_deplibs=yes + ;; + + sunos4*) + if test "x$host_vendor" = xsequent; then + # Use $CC to link under sequent, because it throws in some extra .o + # files that make .init and .fini sections work. + archive_cmds='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags' + fi + hardcode_libdir_flag_spec='-L$libdir' + hardcode_direct=yes + hardcode_minus_L=yes + hardcode_shlibpath_var=no + ;; + + sysv4) + case $host_vendor in + sni) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct=yes # is this really true??? + ;; + siemens) + ## LD is ld it makes a PLAMLIB + ## CC just makes a GrossModule. + archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags' + reload_cmds='$CC -r -o $output$reload_objs' + hardcode_direct=no + ;; + motorola) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct=no #Motorola manual says yes, but my tests say they lie + ;; + esac + runpath_var='LD_RUN_PATH' + hardcode_shlibpath_var=no + ;; + + sysv4.3*) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var=no + export_dynamic_flag_spec='-Bexport' + ;; + + sysv4*MP*) + if test -d /usr/nec; then + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var=no + runpath_var=LD_RUN_PATH + hardcode_runpath_var=yes + ld_shlibs=yes + fi + ;; + + sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*) + no_undefined_flag='${wl}-z,text' + archive_cmds_need_lc=no + hardcode_shlibpath_var=no + runpath_var='LD_RUN_PATH' + + if test "$GCC" = yes; then + archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + fi + ;; + + sysv5* | sco3.2v5* | sco5v6*) + # Note: We can NOT use -z defs as we might desire, because we do not + # link with -lc, and that would cause any symbols used from libc to + # always be unresolved, which means just about no library would + # ever link correctly. If we're not using GNU ld we use -z text + # though, which does catch some bad symbols but isn't as heavy-handed + # as -z defs. + no_undefined_flag='${wl}-z,text' + allow_undefined_flag='${wl}-z,nodefs' + archive_cmds_need_lc=no + hardcode_shlibpath_var=no + hardcode_libdir_flag_spec='${wl}-R,$libdir' + hardcode_libdir_separator=':' + link_all_deplibs=yes + export_dynamic_flag_spec='${wl}-Bexport' + runpath_var='LD_RUN_PATH' + + if test "$GCC" = yes; then + archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + fi + ;; + + uts4*) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec='-L$libdir' + hardcode_shlibpath_var=no + ;; + + *) + ld_shlibs=no + ;; + esac + + if test x$host_vendor = xsni; then + case $host in + sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + export_dynamic_flag_spec='${wl}-Blargedynsym' + ;; + esac + fi + fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs" >&5 +$as_echo "$ld_shlibs" >&6; } +test "$ld_shlibs" = no && can_build_shared=no + +with_gnu_ld=$with_gnu_ld + + + + + + + + + + + + + + + +# +# Do we need to explicitly link libc? +# +case "x$archive_cmds_need_lc" in +x|xyes) + # Assume -lc should be added + archive_cmds_need_lc=yes + + if test "$enable_shared" = yes && test "$GCC" = yes; then + case $archive_cmds in + *'~'*) + # FIXME: we may have to deal with multi-command sequences. + ;; + '$CC '*) + # Test whether the compiler implicitly links with -lc since on some + # systems, -lgcc has to come before -lc. If gcc already passes -lc + # to ld, don't add -lc before -lgcc. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 +$as_echo_n "checking whether -lc should be explicitly linked in... " >&6; } +if ${lt_cv_archive_cmds_need_lc+:} false; then : + $as_echo_n "(cached) " >&6 +else + $RM conftest* + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } 2>conftest.err; then + soname=conftest + lib=conftest + libobjs=conftest.$ac_objext + deplibs= + wl=$lt_prog_compiler_wl + pic_flag=$lt_prog_compiler_pic + compiler_flags=-v + linker_flags=-v + verstring= + output_objdir=. + libname=conftest + lt_save_allow_undefined_flag=$allow_undefined_flag + allow_undefined_flag= + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5 + (eval $archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + then + lt_cv_archive_cmds_need_lc=no + else + lt_cv_archive_cmds_need_lc=yes + fi + allow_undefined_flag=$lt_save_allow_undefined_flag + else + cat conftest.err 1>&5 + fi + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc" >&5 +$as_echo "$lt_cv_archive_cmds_need_lc" >&6; } + archive_cmds_need_lc=$lt_cv_archive_cmds_need_lc + ;; + esac + fi + ;; +esac + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 +$as_echo_n "checking dynamic linker characteristics... " >&6; } + +if test "$GCC" = yes; then + case $host_os in + darwin*) lt_awk_arg="/^libraries:/,/LR/" ;; + *) lt_awk_arg="/^libraries:/" ;; + esac + case $host_os in + mingw* | cegcc*) lt_sed_strip_eq="s,=\([A-Za-z]:\),\1,g" ;; + *) lt_sed_strip_eq="s,=/,/,g" ;; + esac + lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq` + case $lt_search_path_spec in + *\;*) + # if the path contains ";" then we assume it to be the separator + # otherwise default to the standard path separator (i.e. ":") - it is + # assumed that no part of a normal pathname contains ";" but that should + # okay in the real world where ";" in dirpaths is itself problematic. + lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED 's/;/ /g'` + ;; + *) + lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED "s/$PATH_SEPARATOR/ /g"` + ;; + esac + # Ok, now we have the path, separated by spaces, we can step through it + # and add multilib dir if necessary. + lt_tmp_lt_search_path_spec= + lt_multi_os_dir=`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null` + for lt_sys_path in $lt_search_path_spec; do + if test -d "$lt_sys_path/$lt_multi_os_dir"; then + lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path/$lt_multi_os_dir" + else + test -d "$lt_sys_path" && \ + lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path" + fi + done + lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk ' +BEGIN {RS=" "; FS="/|\n";} { + lt_foo=""; + lt_count=0; + for (lt_i = NF; lt_i > 0; lt_i--) { + if ($lt_i != "" && $lt_i != ".") { + if ($lt_i == "..") { + lt_count++; + } else { + if (lt_count == 0) { + lt_foo="/" $lt_i lt_foo; + } else { + lt_count--; + } + } + } + } + if (lt_foo != "") { lt_freq[lt_foo]++; } + if (lt_freq[lt_foo] == 1) { print lt_foo; } +}'` + # AWK program above erroneously prepends '/' to C:/dos/paths + # for these hosts. + case $host_os in + mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\ + $SED 's,/\([A-Za-z]:\),\1,g'` ;; + esac + sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP` +else + sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" +fi +library_names_spec= +libname_spec='lib$name' +soname_spec= +shrext_cmds=".so" +postinstall_cmds= +postuninstall_cmds= +finish_cmds= +finish_eval= +shlibpath_var= +shlibpath_overrides_runpath=unknown +version_type=none +dynamic_linker="$host_os ld.so" +sys_lib_dlsearch_path_spec="/lib /usr/lib" +need_lib_prefix=unknown +hardcode_into_libs=no + +# when you set need_version to no, make sure it does not cause -set_version +# flags to be left without arguments +need_version=unknown + +case $host_os in +aix3*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' + shlibpath_var=LIBPATH + + # AIX 3 has no versioning support, so we append a major version to the name. + soname_spec='${libname}${release}${shared_ext}$major' + ;; + +aix[4-9]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + hardcode_into_libs=yes + if test "$host_cpu" = ia64; then + # AIX 5 supports IA64 + library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + else + # With GCC up to 2.95.x, collect2 would create an import file + # for dependence libraries. The import file would start with + # the line `#! .'. This would cause the generated library to + # depend on `.', always an invalid library. This was fixed in + # development snapshots of GCC prior to 3.0. + case $host_os in + aix4 | aix4.[01] | aix4.[01].*) + if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' + echo ' yes ' + echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then + : + else + can_build_shared=no + fi + ;; + esac + # AIX (on Power*) has no versioning support, so currently we can not hardcode correct + # soname into executable. Probably we can add versioning support to + # collect2, so additional links can be useful in future. + if test "$aix_use_runtimelinking" = yes; then + # If using run time linking (on AIX 4.2 or later) use lib.so + # instead of lib.a to let people know that these are not + # typical AIX shared libraries. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + else + # We preserve .a as extension for shared libraries through AIX4.2 + # and later when we are not doing run time linking. + library_names_spec='${libname}${release}.a $libname.a' + soname_spec='${libname}${release}${shared_ext}$major' + fi + shlibpath_var=LIBPATH + fi + ;; + +amigaos*) + case $host_cpu in + powerpc) + # Since July 2007 AmigaOS4 officially supports .so libraries. + # When compiling the executable, add -use-dynld -Lsobjs: to the compileline. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + ;; + m68k) + library_names_spec='$libname.ixlibrary $libname.a' + # Create ${libname}_ixlibrary.a entries in /sys/libs. + finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' + ;; + esac + ;; + +beos*) + library_names_spec='${libname}${shared_ext}' + dynamic_linker="$host_os ld.so" + shlibpath_var=LIBRARY_PATH + ;; + +bsdi[45]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" + sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" + # the default ld.so.conf also contains /usr/contrib/lib and + # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow + # libtool to hard-code these into programs + ;; + +cygwin* | mingw* | pw32* | cegcc*) + version_type=windows + shrext_cmds=".dll" + need_version=no + need_lib_prefix=no + + case $GCC,$cc_basename in + yes,*) + # gcc + library_names_spec='$libname.dll.a' + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname~ + chmod a+x \$dldir/$dlname~ + if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then + eval '\''$striplib \$dldir/$dlname'\'' || exit \$?; + fi' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $RM \$dlpath' + shlibpath_overrides_runpath=yes + + case $host_os in + cygwin*) + # Cygwin DLLs use 'cyg' prefix rather than 'lib' + soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + + sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api" + ;; + mingw* | cegcc*) + # MinGW DLLs use traditional 'lib' prefix + soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + ;; + pw32*) + # pw32 DLLs use 'pw' prefix rather than 'lib' + library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + ;; + esac + dynamic_linker='Win32 ld.exe' + ;; + + *,cl*) + # Native MSVC + libname_spec='$name' + soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + library_names_spec='${libname}.dll.lib' + + case $build_os in + mingw*) + sys_lib_search_path_spec= + lt_save_ifs=$IFS + IFS=';' + for lt_path in $LIB + do + IFS=$lt_save_ifs + # Let DOS variable expansion print the short 8.3 style file name. + lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"` + sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path" + done + IFS=$lt_save_ifs + # Convert to MSYS style. + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'` + ;; + cygwin*) + # Convert to unix form, then to dos form, then back to unix form + # but this time dos style (no spaces!) so that the unix form looks + # like /cygdrive/c/PROGRA~1:/cygdr... + sys_lib_search_path_spec=`cygpath --path --unix "$LIB"` + sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null` + sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + ;; + *) + sys_lib_search_path_spec="$LIB" + if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then + # It is most probably a Windows format PATH. + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi + # FIXME: find the short name or the path components, as spaces are + # common. (e.g. "Program Files" -> "PROGRA~1") + ;; + esac + + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $RM \$dlpath' + shlibpath_overrides_runpath=yes + dynamic_linker='Win32 link.exe' + ;; + + *) + # Assume MSVC wrapper + library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib' + dynamic_linker='Win32 ld.exe' + ;; + esac + # FIXME: first we should search . and the directory the executable is in + shlibpath_var=PATH + ;; + +darwin* | rhapsody*) + dynamic_linker="$host_os dyld" + version_type=darwin + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext' + soname_spec='${libname}${release}${major}$shared_ext' + shlibpath_overrides_runpath=yes + shlibpath_var=DYLD_LIBRARY_PATH + shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`' + + sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib" + sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib' + ;; + +dgux*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +freebsd* | dragonfly*) + # DragonFly does not have aout. When/if they implement a new + # versioning mechanism, adjust this. + if test -x /usr/bin/objformat; then + objformat=`/usr/bin/objformat` + else + case $host_os in + freebsd[23].*) objformat=aout ;; + *) objformat=elf ;; + esac + fi + version_type=freebsd-$objformat + case $version_type in + freebsd-elf*) + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + need_version=no + need_lib_prefix=no + ;; + freebsd-*) + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' + need_version=yes + ;; + esac + shlibpath_var=LD_LIBRARY_PATH + case $host_os in + freebsd2.*) + shlibpath_overrides_runpath=yes + ;; + freebsd3.[01]* | freebsdelf3.[01]*) + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + freebsd3.[2-9]* | freebsdelf3.[2-9]* | \ + freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1) + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + *) # from 4.6 on, and DragonFly + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + esac + ;; + +haiku*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + dynamic_linker="$host_os runtime_loader" + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LIBRARY_PATH + shlibpath_overrides_runpath=yes + sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib' + hardcode_into_libs=yes + ;; + +hpux9* | hpux10* | hpux11*) + # Give a soname corresponding to the major version so that dld.sl refuses to + # link against other versions. + version_type=sunos + need_lib_prefix=no + need_version=no + case $host_cpu in + ia64*) + shrext_cmds='.so' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.so" + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + if test "X$HPUX_IA64_MODE" = X32; then + sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" + else + sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" + fi + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + hppa*64*) + shrext_cmds='.sl' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.sl" + shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + *) + shrext_cmds='.sl' + dynamic_linker="$host_os dld.sl" + shlibpath_var=SHLIB_PATH + shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + ;; + esac + # HP-UX runs *really* slowly unless shared libraries are mode 555, ... + postinstall_cmds='chmod 555 $lib' + # or fails outright, so override atomically: + install_override_mode=555 + ;; + +interix[3-9]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + +irix5* | irix6* | nonstopux*) + case $host_os in + nonstopux*) version_type=nonstopux ;; + *) + if test "$lt_cv_prog_gnu_ld" = yes; then + version_type=linux # correct to gnu/linux during the next big refactor + else + version_type=irix + fi ;; + esac + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' + case $host_os in + irix5* | nonstopux*) + libsuff= shlibsuff= + ;; + *) + case $LD in # libtool.m4 will add one of these switches to LD + *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") + libsuff= shlibsuff= libmagic=32-bit;; + *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") + libsuff=32 shlibsuff=N32 libmagic=N32;; + *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") + libsuff=64 shlibsuff=64 libmagic=64-bit;; + *) libsuff= shlibsuff= libmagic=never-match;; + esac + ;; + esac + shlibpath_var=LD_LIBRARY${shlibsuff}_PATH + shlibpath_overrides_runpath=no + sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" + sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" + hardcode_into_libs=yes + ;; + +# No shared lib support for Linux oldld, aout, or coff. +linux*oldld* | linux*aout* | linux*coff*) + dynamic_linker=no + ;; + +# This must be glibc/ELF. +linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + + # Some binutils ld are patched to set DT_RUNPATH + if ${lt_cv_shlibpath_overrides_runpath+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_shlibpath_overrides_runpath=no + save_LDFLAGS=$LDFLAGS + save_libdir=$libdir + eval "libdir=/foo; wl=\"$lt_prog_compiler_wl\"; \ + LDFLAGS=\"\$LDFLAGS $hardcode_libdir_flag_spec\"" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + if ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null; then : + lt_cv_shlibpath_overrides_runpath=yes +fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + LDFLAGS=$save_LDFLAGS + libdir=$save_libdir + +fi + + shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath + + # This implies no fast_install, which is unacceptable. + # Some rework will be needed to allow for fast_install + # before this can be enabled. + hardcode_into_libs=yes + + # Append ld.so.conf contents to the search path + if test -f /etc/ld.so.conf; then + lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '` + sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra" + fi + + # We used to test for /lib/ld.so.1 and disable shared libraries on + # powerpc, because MkLinux only supported shared libraries with the + # GNU dynamic linker. Since this was broken with cross compilers, + # most powerpc-linux boxes support dynamic linking these days and + # people can always --disable-shared, the test was removed, and we + # assume the GNU/Linux dynamic linker is in use. + dynamic_linker='GNU/Linux ld.so' + ;; + +netbsdelf*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='NetBSD ld.elf_so' + ;; + +netbsd*) + version_type=sunos + need_lib_prefix=no + need_version=no + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + dynamic_linker='NetBSD (a.out) ld.so' + else + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='NetBSD ld.elf_so' + fi + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + +newsos6) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +*nto* | *qnx*) + version_type=qnx + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='ldqnx.so' + ;; + +openbsd*) + version_type=sunos + sys_lib_dlsearch_path_spec="/usr/lib" + need_lib_prefix=no + # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs. + case $host_os in + openbsd3.3 | openbsd3.3.*) need_version=yes ;; + *) need_version=no ;; + esac + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + shlibpath_var=LD_LIBRARY_PATH + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + case $host_os in + openbsd2.[89] | openbsd2.[89].*) + shlibpath_overrides_runpath=no + ;; + *) + shlibpath_overrides_runpath=yes + ;; + esac + else + shlibpath_overrides_runpath=yes + fi + ;; + +os2*) + libname_spec='$name' + shrext_cmds=".dll" + need_lib_prefix=no + library_names_spec='$libname${shared_ext} $libname.a' + dynamic_linker='OS/2 ld.exe' + shlibpath_var=LIBPATH + ;; + +osf3* | osf4* | osf5*) + version_type=osf + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" + sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" + ;; + +rdos*) + dynamic_linker=no + ;; + +solaris*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + # ldd complains unless libraries are executable + postinstall_cmds='chmod +x $lib' + ;; + +sunos4*) + version_type=sunos + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + if test "$with_gnu_ld" = yes; then + need_lib_prefix=no + fi + need_version=yes + ;; + +sysv4 | sysv4.3*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + case $host_vendor in + sni) + shlibpath_overrides_runpath=no + need_lib_prefix=no + runpath_var=LD_RUN_PATH + ;; + siemens) + need_lib_prefix=no + ;; + motorola) + need_lib_prefix=no + need_version=no + shlibpath_overrides_runpath=no + sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' + ;; + esac + ;; + +sysv4*MP*) + if test -d /usr/nec ;then + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' + soname_spec='$libname${shared_ext}.$major' + shlibpath_var=LD_LIBRARY_PATH + fi + ;; + +sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) + version_type=freebsd-elf + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + if test "$with_gnu_ld" = yes; then + sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib' + else + sys_lib_search_path_spec='/usr/ccs/lib /usr/lib' + case $host_os in + sco3.2v5*) + sys_lib_search_path_spec="$sys_lib_search_path_spec /lib" + ;; + esac + fi + sys_lib_dlsearch_path_spec='/usr/lib' + ;; + +tpf*) + # TPF is a cross-target only. Preferred cross-host = GNU/Linux. + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + +uts4*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +*) + dynamic_linker=no + ;; +esac +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 +$as_echo "$dynamic_linker" >&6; } +test "$dynamic_linker" = no && can_build_shared=no + +variables_saved_for_relink="PATH $shlibpath_var $runpath_var" +if test "$GCC" = yes; then + variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" +fi + +if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then + sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec" +fi +if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then + sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec" +fi + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 +$as_echo_n "checking how to hardcode library paths into programs... " >&6; } +hardcode_action= +if test -n "$hardcode_libdir_flag_spec" || + test -n "$runpath_var" || + test "X$hardcode_automatic" = "Xyes" ; then + + # We can hardcode non-existent directories. + if test "$hardcode_direct" != no && + # If the only mechanism to avoid hardcoding is shlibpath_var, we + # have to relink, otherwise we might link with an installed library + # when we should be linking with a yet-to-be-installed one + ## test "$_LT_TAGVAR(hardcode_shlibpath_var, )" != no && + test "$hardcode_minus_L" != no; then + # Linking always hardcodes the temporary library directory. + hardcode_action=relink + else + # We can link without hardcoding, and we can hardcode nonexisting dirs. + hardcode_action=immediate + fi +else + # We cannot hardcode anything, or else we can only hardcode existing + # directories. + hardcode_action=unsupported +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action" >&5 +$as_echo "$hardcode_action" >&6; } + +if test "$hardcode_action" = relink || + test "$inherit_rpath" = yes; then + # Fast installation is not supported + enable_fast_install=no +elif test "$shlibpath_overrides_runpath" = yes || + test "$enable_shared" = no; then + # Fast installation is not necessary + enable_fast_install=needless +fi + + + + + + + if test "x$enable_dlopen" != xyes; then + enable_dlopen=unknown + enable_dlopen_self=unknown + enable_dlopen_self_static=unknown +else + lt_cv_dlopen=no + lt_cv_dlopen_libs= + + case $host_os in + beos*) + lt_cv_dlopen="load_add_on" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + ;; + + mingw* | pw32* | cegcc*) + lt_cv_dlopen="LoadLibrary" + lt_cv_dlopen_libs= + ;; + + cygwin*) + lt_cv_dlopen="dlopen" + lt_cv_dlopen_libs= + ;; + + darwin*) + # if libdl is installed we need to link against it + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 +$as_echo_n "checking for dlopen in -ldl... " >&6; } +if ${ac_cv_lib_dl_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldl $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dl_dlopen=yes +else + ac_cv_lib_dl_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +$as_echo "$ac_cv_lib_dl_dlopen" >&6; } +if test "x$ac_cv_lib_dl_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" +else + + lt_cv_dlopen="dyld" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + +fi + + ;; + + *) + ac_fn_c_check_func "$LINENO" "shl_load" "ac_cv_func_shl_load" +if test "x$ac_cv_func_shl_load" = xyes; then : + lt_cv_dlopen="shl_load" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5 +$as_echo_n "checking for shl_load in -ldld... " >&6; } +if ${ac_cv_lib_dld_shl_load+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char shl_load (); +int +main () +{ +return shl_load (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dld_shl_load=yes +else + ac_cv_lib_dld_shl_load=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5 +$as_echo "$ac_cv_lib_dld_shl_load" >&6; } +if test "x$ac_cv_lib_dld_shl_load" = xyes; then : + lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld" +else + ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen" +if test "x$ac_cv_func_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 +$as_echo_n "checking for dlopen in -ldl... " >&6; } +if ${ac_cv_lib_dl_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldl $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dl_dlopen=yes +else + ac_cv_lib_dl_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +$as_echo "$ac_cv_lib_dl_dlopen" >&6; } +if test "x$ac_cv_lib_dl_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5 +$as_echo_n "checking for dlopen in -lsvld... " >&6; } +if ${ac_cv_lib_svld_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lsvld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_svld_dlopen=yes +else + ac_cv_lib_svld_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5 +$as_echo "$ac_cv_lib_svld_dlopen" >&6; } +if test "x$ac_cv_lib_svld_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5 +$as_echo_n "checking for dld_link in -ldld... " >&6; } +if ${ac_cv_lib_dld_dld_link+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dld_link (); +int +main () +{ +return dld_link (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dld_dld_link=yes +else + ac_cv_lib_dld_dld_link=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5 +$as_echo "$ac_cv_lib_dld_dld_link" >&6; } +if test "x$ac_cv_lib_dld_dld_link" = xyes; then : + lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld" +fi + + +fi + + +fi + + +fi + + +fi + + +fi + + ;; + esac + + if test "x$lt_cv_dlopen" != xno; then + enable_dlopen=yes + else + enable_dlopen=no + fi + + case $lt_cv_dlopen in + dlopen) + save_CPPFLAGS="$CPPFLAGS" + test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H" + + save_LDFLAGS="$LDFLAGS" + wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\" + + save_LIBS="$LIBS" + LIBS="$lt_cv_dlopen_libs $LIBS" + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5 +$as_echo_n "checking whether a program can dlopen itself... " >&6; } +if ${lt_cv_dlopen_self+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "$cross_compiling" = yes; then : + lt_cv_dlopen_self=cross +else + lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 + lt_status=$lt_dlunknown + cat > conftest.$ac_ext <<_LT_EOF +#line $LINENO "configure" +#include "confdefs.h" + +#if HAVE_DLFCN_H +#include +#endif + +#include + +#ifdef RTLD_GLOBAL +# define LT_DLGLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_DLGLOBAL DL_GLOBAL +# else +# define LT_DLGLOBAL 0 +# endif +#endif + +/* We may have to define LT_DLLAZY_OR_NOW in the command line if we + find out it does not work in some platform. */ +#ifndef LT_DLLAZY_OR_NOW +# ifdef RTLD_LAZY +# define LT_DLLAZY_OR_NOW RTLD_LAZY +# else +# ifdef DL_LAZY +# define LT_DLLAZY_OR_NOW DL_LAZY +# else +# ifdef RTLD_NOW +# define LT_DLLAZY_OR_NOW RTLD_NOW +# else +# ifdef DL_NOW +# define LT_DLLAZY_OR_NOW DL_NOW +# else +# define LT_DLLAZY_OR_NOW 0 +# endif +# endif +# endif +# endif +#endif + +/* When -fvisbility=hidden is used, assume the code has been annotated + correspondingly for the symbols needed. */ +#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)) +int fnord () __attribute__((visibility("default"))); +#endif + +int fnord () { return 42; } +int main () +{ + void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); + int status = $lt_dlunknown; + + if (self) + { + if (dlsym (self,"fnord")) status = $lt_dlno_uscore; + else + { + if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; + else puts (dlerror ()); + } + /* dlclose (self); */ + } + else + puts (dlerror ()); + + return status; +} +_LT_EOF + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then + (./conftest; exit; ) >&5 2>/dev/null + lt_status=$? + case x$lt_status in + x$lt_dlno_uscore) lt_cv_dlopen_self=yes ;; + x$lt_dlneed_uscore) lt_cv_dlopen_self=yes ;; + x$lt_dlunknown|x*) lt_cv_dlopen_self=no ;; + esac + else : + # compilation failed + lt_cv_dlopen_self=no + fi +fi +rm -fr conftest* + + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5 +$as_echo "$lt_cv_dlopen_self" >&6; } + + if test "x$lt_cv_dlopen_self" = xyes; then + wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5 +$as_echo_n "checking whether a statically linked program can dlopen itself... " >&6; } +if ${lt_cv_dlopen_self_static+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "$cross_compiling" = yes; then : + lt_cv_dlopen_self_static=cross +else + lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 + lt_status=$lt_dlunknown + cat > conftest.$ac_ext <<_LT_EOF +#line $LINENO "configure" +#include "confdefs.h" + +#if HAVE_DLFCN_H +#include +#endif + +#include + +#ifdef RTLD_GLOBAL +# define LT_DLGLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_DLGLOBAL DL_GLOBAL +# else +# define LT_DLGLOBAL 0 +# endif +#endif + +/* We may have to define LT_DLLAZY_OR_NOW in the command line if we + find out it does not work in some platform. */ +#ifndef LT_DLLAZY_OR_NOW +# ifdef RTLD_LAZY +# define LT_DLLAZY_OR_NOW RTLD_LAZY +# else +# ifdef DL_LAZY +# define LT_DLLAZY_OR_NOW DL_LAZY +# else +# ifdef RTLD_NOW +# define LT_DLLAZY_OR_NOW RTLD_NOW +# else +# ifdef DL_NOW +# define LT_DLLAZY_OR_NOW DL_NOW +# else +# define LT_DLLAZY_OR_NOW 0 +# endif +# endif +# endif +# endif +#endif + +/* When -fvisbility=hidden is used, assume the code has been annotated + correspondingly for the symbols needed. */ +#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)) +int fnord () __attribute__((visibility("default"))); +#endif + +int fnord () { return 42; } +int main () +{ + void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); + int status = $lt_dlunknown; + + if (self) + { + if (dlsym (self,"fnord")) status = $lt_dlno_uscore; + else + { + if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; + else puts (dlerror ()); + } + /* dlclose (self); */ + } + else + puts (dlerror ()); + + return status; +} +_LT_EOF + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then + (./conftest; exit; ) >&5 2>/dev/null + lt_status=$? + case x$lt_status in + x$lt_dlno_uscore) lt_cv_dlopen_self_static=yes ;; + x$lt_dlneed_uscore) lt_cv_dlopen_self_static=yes ;; + x$lt_dlunknown|x*) lt_cv_dlopen_self_static=no ;; + esac + else : + # compilation failed + lt_cv_dlopen_self_static=no + fi +fi +rm -fr conftest* + + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5 +$as_echo "$lt_cv_dlopen_self_static" >&6; } + fi + + CPPFLAGS="$save_CPPFLAGS" + LDFLAGS="$save_LDFLAGS" + LIBS="$save_LIBS" + ;; + esac + + case $lt_cv_dlopen_self in + yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;; + *) enable_dlopen_self=unknown ;; + esac + + case $lt_cv_dlopen_self_static in + yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;; + *) enable_dlopen_self_static=unknown ;; + esac +fi + + + + + + + + + + + + + + + + + +striplib= +old_striplib= +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5 +$as_echo_n "checking whether stripping libraries is possible... " >&6; } +if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then + test -z "$old_striplib" && old_striplib="$STRIP --strip-debug" + test -z "$striplib" && striplib="$STRIP --strip-unneeded" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +else +# FIXME - insert some real tests, host_os isn't really good enough + case $host_os in + darwin*) + if test -n "$STRIP" ; then + striplib="$STRIP -x" + old_striplib="$STRIP -S" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + fi + ;; + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + ;; + esac +fi + + + + + + + + + + + + + # Report which library types will actually be built + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5 +$as_echo_n "checking if libtool supports shared libraries... " >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5 +$as_echo "$can_build_shared" >&6; } + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5 +$as_echo_n "checking whether to build shared libraries... " >&6; } + test "$can_build_shared" = "no" && enable_shared=no + + # On AIX, shared libraries and static libraries use the same namespace, and + # are all built from PIC. + case $host_os in + aix3*) + test "$enable_shared" = yes && enable_static=no + if test -n "$RANLIB"; then + archive_cmds="$archive_cmds~\$RANLIB \$lib" + postinstall_cmds='$RANLIB $lib' + fi + ;; + + aix[4-9]*) + if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then + test "$enable_shared" = yes && enable_static=no + fi + ;; + esac + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_shared" >&5 +$as_echo "$enable_shared" >&6; } + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5 +$as_echo_n "checking whether to build static libraries... " >&6; } + # Make sure either enable_shared or enable_static is yes. + test "$enable_shared" = yes || enable_static=yes + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5 +$as_echo "$enable_static" >&6; } + + + + +fi +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +CC="$lt_save_CC" + + if test -n "$CXX" && ( test "X$CXX" != "Xno" && + ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) || + (test "X$CXX" != "Xg++"))) ; then + ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5 +$as_echo_n "checking how to run the C++ preprocessor... " >&6; } +if test -z "$CXXCPP"; then + if ${ac_cv_prog_CXXCPP+:} false; then : + $as_echo_n "(cached) " >&6 +else + # Double quotes because CXXCPP needs to be expanded + for CXXCPP in "$CXX -E" "/lib/cpp" + do + ac_preproc_ok=false +for ac_cxx_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + break +fi + + done + ac_cv_prog_CXXCPP=$CXXCPP + +fi + CXXCPP=$ac_cv_prog_CXXCPP +else + ac_cv_prog_CXXCPP=$CXXCPP +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5 +$as_echo "$CXXCPP" >&6; } +ac_preproc_ok=false +for ac_cxx_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + +else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check +See \`config.log' for more details" "$LINENO" 5; } +fi + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +else + _lt_caught_CXX_error=yes +fi + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + +archive_cmds_need_lc_CXX=no +allow_undefined_flag_CXX= +always_export_symbols_CXX=no +archive_expsym_cmds_CXX= +compiler_needs_object_CXX=no +export_dynamic_flag_spec_CXX= +hardcode_direct_CXX=no +hardcode_direct_absolute_CXX=no +hardcode_libdir_flag_spec_CXX= +hardcode_libdir_separator_CXX= +hardcode_minus_L_CXX=no +hardcode_shlibpath_var_CXX=unsupported +hardcode_automatic_CXX=no +inherit_rpath_CXX=no +module_cmds_CXX= +module_expsym_cmds_CXX= +link_all_deplibs_CXX=unknown +old_archive_cmds_CXX=$old_archive_cmds +reload_flag_CXX=$reload_flag +reload_cmds_CXX=$reload_cmds +no_undefined_flag_CXX= +whole_archive_flag_spec_CXX= +enable_shared_with_static_runtimes_CXX=no + +# Source file extension for C++ test sources. +ac_ext=cpp + +# Object file extension for compiled C++ test sources. +objext=o +objext_CXX=$objext + +# No sense in running all these tests if we already determined that +# the CXX compiler isn't working. Some variables (like enable_shared) +# are currently assumed to apply to all compilers on this platform, +# and will be corrupted by setting them based on a non-working compiler. +if test "$_lt_caught_CXX_error" != yes; then + # Code to be used in simple compile tests + lt_simple_compile_test_code="int some_variable = 0;" + + # Code to be used in simple link tests + lt_simple_link_test_code='int main(int, char *[]) { return(0); }' + + # ltmain only uses $CC for tagged configurations so make sure $CC is set. + + + + + + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# If no C compiler flags were specified, use CFLAGS. +LTCFLAGS=${LTCFLAGS-"$CFLAGS"} + +# Allow CC to be a program name with arguments. +compiler=$CC + + + # save warnings/boilerplate of simple test code + ac_outfile=conftest.$ac_objext +echo "$lt_simple_compile_test_code" >conftest.$ac_ext +eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err +_lt_compiler_boilerplate=`cat conftest.err` +$RM conftest* + + ac_outfile=conftest.$ac_objext +echo "$lt_simple_link_test_code" >conftest.$ac_ext +eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err +_lt_linker_boilerplate=`cat conftest.err` +$RM -r conftest* + + + # Allow CC to be a program name with arguments. + lt_save_CC=$CC + lt_save_CFLAGS=$CFLAGS + lt_save_LD=$LD + lt_save_GCC=$GCC + GCC=$GXX + lt_save_with_gnu_ld=$with_gnu_ld + lt_save_path_LD=$lt_cv_path_LD + if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then + lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx + else + $as_unset lt_cv_prog_gnu_ld + fi + if test -n "${lt_cv_path_LDCXX+set}"; then + lt_cv_path_LD=$lt_cv_path_LDCXX + else + $as_unset lt_cv_path_LD + fi + test -z "${LDCXX+set}" || LD=$LDCXX + CC=${CXX-"c++"} + CFLAGS=$CXXFLAGS + compiler=$CC + compiler_CXX=$CC + for cc_temp in $compiler""; do + case $cc_temp in + compile | *[\\/]compile | ccache | *[\\/]ccache ) ;; + distcc | *[\\/]distcc | purify | *[\\/]purify ) ;; + \-*) ;; + *) break;; + esac +done +cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` + + + if test -n "$compiler"; then + # We don't want -fno-exception when compiling C++ code, so set the + # no_builtin_flag separately + if test "$GXX" = yes; then + lt_prog_compiler_no_builtin_flag_CXX=' -fno-builtin' + else + lt_prog_compiler_no_builtin_flag_CXX= + fi + + if test "$GXX" = yes; then + # Set up default GNU C++ configuration + + + +# Check whether --with-gnu-ld was given. +if test "${with_gnu_ld+set}" = set; then : + withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes +else + with_gnu_ld=no +fi + +ac_prog=ld +if test "$GCC" = yes; then + # Check if gcc -print-prog-name=ld gives a path. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 +$as_echo_n "checking for ld used by $CC... " >&6; } + case $host in + *-*-mingw*) + # gcc leaves a trailing carriage return which upsets mingw + ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; + *) + ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; + esac + case $ac_prog in + # Accept absolute paths. + [\\/]* | ?:[\\/]*) + re_direlt='/[^/][^/]*/\.\./' + # Canonicalize the pathname of ld + ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'` + while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do + ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"` + done + test -z "$LD" && LD="$ac_prog" + ;; + "") + # If it fails, then pretend we aren't using GCC. + ac_prog=ld + ;; + *) + # If it is relative, then search for the first ld in PATH. + with_gnu_ld=unknown + ;; + esac +elif test "$with_gnu_ld" = yes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 +$as_echo_n "checking for GNU ld... " >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5 +$as_echo_n "checking for non-GNU ld... " >&6; } +fi +if ${lt_cv_path_LD+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$LD"; then + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then + lt_cv_path_LD="$ac_dir/$ac_prog" + # Check to see if the program is GNU ld. I'd rather use --version, + # but apparently some variants of GNU ld only accept -v. + # Break only if it was the GNU/non-GNU ld that we prefer. + case `"$lt_cv_path_LD" -v 2>&1 &5 +$as_echo "$LD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi +test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5 +$as_echo_n "checking if the linker ($LD) is GNU ld... " >&6; } +if ${lt_cv_prog_gnu_ld+:} false; then : + $as_echo_n "(cached) " >&6 +else + # I'd rather use --version here, but apparently some GNU lds only accept -v. +case `$LD -v 2>&1 &5 +$as_echo "$lt_cv_prog_gnu_ld" >&6; } +with_gnu_ld=$lt_cv_prog_gnu_ld + + + + + + + + # Check if GNU C++ uses GNU ld as the underlying linker, since the + # archiving commands below assume that GNU ld is being used. + if test "$with_gnu_ld" = yes; then + archive_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + + hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-dynamic' + + # If archive_cmds runs LD, not CC, wlarc should be empty + # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to + # investigate it a little bit more. (MM) + wlarc='${wl}' + + # ancient GNU ld didn't support --whole-archive et. al. + if eval "`$CC -print-prog-name=ld` --help 2>&1" | + $GREP 'no-whole-archive' > /dev/null; then + whole_archive_flag_spec_CXX="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + else + whole_archive_flag_spec_CXX= + fi + else + with_gnu_ld=no + wlarc= + + # A generic and very simple default shared library creation + # command for GNU C++ for the case where it uses the native + # linker, instead of GNU ld. If possible, this setting should + # overridden to take advantage of the native linker features on + # the platform it is being used on. + archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' + fi + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + + else + GXX=no + with_gnu_ld=no + wlarc= + fi + + # PORTME: fill in a description of your system's C++ link characteristics + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 +$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } + ld_shlibs_CXX=yes + case $host_os in + aix3*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + aix[4-9]*) + if test "$host_cpu" = ia64; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag="" + else + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # need to do runtime linking. + case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*) + for ld_flag in $LDFLAGS; do + case $ld_flag in + *-brtl*) + aix_use_runtimelinking=yes + break + ;; + esac + done + ;; + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + archive_cmds_CXX='' + hardcode_direct_CXX=yes + hardcode_direct_absolute_CXX=yes + hardcode_libdir_separator_CXX=':' + link_all_deplibs_CXX=yes + file_list_spec_CXX='${wl}-f,' + + if test "$GXX" = yes; then + case $host_os in aix4.[012]|aix4.[012].*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`${CC} -print-prog-name=collect2` + if test -f "$collect2name" && + strings "$collect2name" | $GREP resolve_lib_name >/dev/null + then + # We have reworked collect2 + : + else + # We have old collect2 + hardcode_direct_CXX=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + hardcode_minus_L_CXX=yes + hardcode_libdir_flag_spec_CXX='-L$libdir' + hardcode_libdir_separator_CXX= + fi + esac + shared_flag='-shared' + if test "$aix_use_runtimelinking" = yes; then + shared_flag="$shared_flag "'${wl}-G' + fi + else + # not using gcc + if test "$host_cpu" = ia64; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test "$aix_use_runtimelinking" = yes; then + shared_flag='${wl}-G' + else + shared_flag='${wl}-bM:SRE' + fi + fi + fi + + export_dynamic_flag_spec_CXX='${wl}-bexpall' + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to + # export. + always_export_symbols_CXX=yes + if test "$aix_use_runtimelinking" = yes; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + allow_undefined_flag_CXX='-berok' + # Determine the default libpath from the value encoded in an empty + # executable. + if test "${lt_cv_aix_libpath+set}" = set; then + aix_libpath=$lt_cv_aix_libpath +else + if ${lt_cv_aix_libpath__CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + + lt_aix_libpath_sed=' + /Import File Strings/,/^$/ { + /^0/ { + s/^0 *\([^ ]*\) *$/\1/ + p + } + }' + lt_cv_aix_libpath__CXX=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + # Check for a 64-bit object if we didn't find anything. + if test -z "$lt_cv_aix_libpath__CXX"; then + lt_cv_aix_libpath__CXX=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + if test -z "$lt_cv_aix_libpath__CXX"; then + lt_cv_aix_libpath__CXX="/usr/lib:/lib" + fi + +fi + + aix_libpath=$lt_cv_aix_libpath__CXX +fi + + hardcode_libdir_flag_spec_CXX='${wl}-blibpath:$libdir:'"$aix_libpath" + + archive_expsym_cmds_CXX='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag" + else + if test "$host_cpu" = ia64; then + hardcode_libdir_flag_spec_CXX='${wl}-R $libdir:/usr/lib:/lib' + allow_undefined_flag_CXX="-z nodefs" + archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an + # empty executable. + if test "${lt_cv_aix_libpath+set}" = set; then + aix_libpath=$lt_cv_aix_libpath +else + if ${lt_cv_aix_libpath__CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + + lt_aix_libpath_sed=' + /Import File Strings/,/^$/ { + /^0/ { + s/^0 *\([^ ]*\) *$/\1/ + p + } + }' + lt_cv_aix_libpath__CXX=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + # Check for a 64-bit object if we didn't find anything. + if test -z "$lt_cv_aix_libpath__CXX"; then + lt_cv_aix_libpath__CXX=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + if test -z "$lt_cv_aix_libpath__CXX"; then + lt_cv_aix_libpath__CXX="/usr/lib:/lib" + fi + +fi + + aix_libpath=$lt_cv_aix_libpath__CXX +fi + + hardcode_libdir_flag_spec_CXX='${wl}-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + no_undefined_flag_CXX=' ${wl}-bernotok' + allow_undefined_flag_CXX=' ${wl}-berok' + if test "$with_gnu_ld" = yes; then + # We only use this code for GNU lds that support --whole-archive. + whole_archive_flag_spec_CXX='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + else + # Exported symbols can be pulled into shared objects from archives + whole_archive_flag_spec_CXX='$convenience' + fi + archive_cmds_need_lc_CXX=yes + # This is similar to how AIX traditionally builds its shared + # libraries. + archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + fi + fi + ;; + + beos*) + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + allow_undefined_flag_CXX=unsupported + # Joseph Beckenbach says some releases of gcc + # support --undefined. This deserves some investigation. FIXME + archive_cmds_CXX='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + else + ld_shlibs_CXX=no + fi + ;; + + chorus*) + case $cc_basename in + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + + cygwin* | mingw* | pw32* | cegcc*) + case $GXX,$cc_basename in + ,cl* | no,cl*) + # Native MSVC + # hardcode_libdir_flag_spec is actually meaningless, as there is + # no search path for DLLs. + hardcode_libdir_flag_spec_CXX=' ' + allow_undefined_flag_CXX=unsupported + always_export_symbols_CXX=yes + file_list_spec_CXX='@' + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + archive_cmds_CXX='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames=' + archive_expsym_cmds_CXX='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + $SED -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp; + else + $SED -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp; + fi~ + $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ + linknames=' + # The linker will not automatically build a static lib if we build a DLL. + # _LT_TAGVAR(old_archive_from_new_cmds, CXX)='true' + enable_shared_with_static_runtimes_CXX=yes + # Don't use ranlib + old_postinstall_cmds_CXX='chmod 644 $oldlib' + postlink_cmds_CXX='lt_outputfile="@OUTPUT@"~ + lt_tool_outputfile="@TOOL_OUTPUT@"~ + case $lt_outputfile in + *.exe|*.EXE) ;; + *) + lt_outputfile="$lt_outputfile.exe" + lt_tool_outputfile="$lt_tool_outputfile.exe" + ;; + esac~ + func_to_tool_file "$lt_outputfile"~ + if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then + $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; + $RM "$lt_outputfile.manifest"; + fi' + ;; + *) + # g++ + # _LT_TAGVAR(hardcode_libdir_flag_spec, CXX) is actually meaningless, + # as there is no search path for DLLs. + hardcode_libdir_flag_spec_CXX='-L$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-all-symbols' + allow_undefined_flag_CXX=unsupported + always_export_symbols_CXX=no + enable_shared_with_static_runtimes_CXX=yes + + if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then + archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + # If the export-symbols file already is a .def file (1st line + # is EXPORTS), use it as is; otherwise, prepend... + archive_expsym_cmds_CXX='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + else + ld_shlibs_CXX=no + fi + ;; + esac + ;; + darwin* | rhapsody*) + + + archive_cmds_need_lc_CXX=no + hardcode_direct_CXX=no + hardcode_automatic_CXX=yes + hardcode_shlibpath_var_CXX=unsupported + if test "$lt_cv_ld_force_load" = "yes"; then + whole_archive_flag_spec_CXX='`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`' + + else + whole_archive_flag_spec_CXX='' + fi + link_all_deplibs_CXX=yes + allow_undefined_flag_CXX="$_lt_dar_allow_undefined" + case $cc_basename in + ifort*) _lt_dar_can_shared=yes ;; + *) _lt_dar_can_shared=$GCC ;; + esac + if test "$_lt_dar_can_shared" = "yes"; then + output_verbose_link_cmd=func_echo_all + archive_cmds_CXX="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}" + module_cmds_CXX="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}" + archive_expsym_cmds_CXX="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}" + module_expsym_cmds_CXX="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}" + if test "$lt_cv_apple_cc_single_mod" != "yes"; then + archive_cmds_CXX="\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dsymutil}" + archive_expsym_cmds_CXX="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dar_export_syms}${_lt_dsymutil}" + fi + + else + ld_shlibs_CXX=no + fi + + ;; + + dgux*) + case $cc_basename in + ec++*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + ghcx*) + # Green Hills C++ Compiler + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + + freebsd2.*) + # C++ shared libraries reported to be fairly broken before + # switch to ELF + ld_shlibs_CXX=no + ;; + + freebsd-elf*) + archive_cmds_need_lc_CXX=no + ;; + + freebsd* | dragonfly*) + # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF + # conventions + ld_shlibs_CXX=yes + ;; + + haiku*) + archive_cmds_CXX='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + link_all_deplibs_CXX=yes + ;; + + hpux9*) + hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir' + hardcode_libdir_separator_CXX=: + export_dynamic_flag_spec_CXX='${wl}-E' + hardcode_direct_CXX=yes + hardcode_minus_L_CXX=yes # Not in the search PATH, + # but as the default + # location of the library. + + case $cc_basename in + CC*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + aCC*) + archive_cmds_CXX='$RM $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + ;; + *) + if test "$GXX" = yes; then + archive_cmds_CXX='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + else + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + fi + ;; + esac + ;; + + hpux10*|hpux11*) + if test $with_gnu_ld = no; then + hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir' + hardcode_libdir_separator_CXX=: + + case $host_cpu in + hppa*64*|ia64*) + ;; + *) + export_dynamic_flag_spec_CXX='${wl}-E' + ;; + esac + fi + case $host_cpu in + hppa*64*|ia64*) + hardcode_direct_CXX=no + hardcode_shlibpath_var_CXX=no + ;; + *) + hardcode_direct_CXX=yes + hardcode_direct_absolute_CXX=yes + hardcode_minus_L_CXX=yes # Not in the search PATH, + # but as the default + # location of the library. + ;; + esac + + case $cc_basename in + CC*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + aCC*) + case $host_cpu in + hppa*64*) + archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + ia64*) + archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + *) + archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + esac + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + ;; + *) + if test "$GXX" = yes; then + if test $with_gnu_ld = no; then + case $host_cpu in + hppa*64*) + archive_cmds_CXX='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + ia64*) + archive_cmds_CXX='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + *) + archive_cmds_CXX='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + esac + fi + else + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + fi + ;; + esac + ;; + + interix[3-9]*) + hardcode_direct_CXX=no + hardcode_shlibpath_var_CXX=no + hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' + export_dynamic_flag_spec_CXX='${wl}-E' + # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc. + # Instead, shared libraries are loaded at an image base (0x10000000 by + # default) and relocated if they conflict, which is a slow very memory + # consuming and fragmenting process. To avoid this, we pick a random, + # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link + # time. Moving up from 0x10000000 also allows more sbrk(2) space. + archive_cmds_CXX='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + archive_expsym_cmds_CXX='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + ;; + irix5* | irix6*) + case $cc_basename in + CC*) + # SGI C++ + archive_cmds_CXX='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + + # Archives containing C++ object files must be created using + # "CC -ar", where "CC" is the IRIX C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + old_archive_cmds_CXX='$CC -ar -WR,-u -o $oldlib $oldobjs' + ;; + *) + if test "$GXX" = yes; then + if test "$with_gnu_ld" = no; then + archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` -o $lib' + fi + fi + link_all_deplibs_CXX=yes + ;; + esac + hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_CXX=: + inherit_rpath_CXX=yes + ;; + + linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + case $cc_basename in + KCC*) + # Kuck and Associates, Inc. (KAI) C++ Compiler + + # KCC will only create a shared library if the output file + # ends with ".so" (or ".sl" for HP-UX), so rename the library + # to its proper name (with version) after linking. + archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + archive_expsym_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib' + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + + hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-dynamic' + + # Archives containing C++ object files must be created using + # "CC -Bstatic", where "CC" is the KAI C++ compiler. + old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs' + ;; + icpc* | ecpc* ) + # Intel C++ + with_gnu_ld=yes + # version 8.0 and above of icpc choke on multiply defined symbols + # if we add $predep_objects and $postdep_objects, however 7.1 and + # earlier do not add the objects themselves. + case `$CC -V 2>&1` in + *"Version 7."*) + archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + ;; + *) # Version 8.0 or newer + tmp_idyn= + case $host_cpu in + ia64*) tmp_idyn=' -i_dynamic';; + esac + archive_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + ;; + esac + archive_cmds_need_lc_CXX=no + hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-dynamic' + whole_archive_flag_spec_CXX='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + ;; + pgCC* | pgcpp*) + # Portland Group C++ compiler + case `$CC -V` in + *pgCC\ [1-5].* | *pgcpp\ [1-5].*) + prelink_cmds_CXX='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~ + compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"' + old_archive_cmds_CXX='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~ + $AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~ + $RANLIB $oldlib' + archive_cmds_CXX='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ + $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib' + archive_expsym_cmds_CXX='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ + $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib' + ;; + *) # Version 6 and above use weak symbols + archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib' + archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib' + ;; + esac + + hardcode_libdir_flag_spec_CXX='${wl}--rpath ${wl}$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-dynamic' + whole_archive_flag_spec_CXX='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + ;; + cxx*) + # Compaq C++ + archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib ${wl}-retain-symbols-file $wl$export_symbols' + + runpath_var=LD_RUN_PATH + hardcode_libdir_flag_spec_CXX='-rpath $libdir' + hardcode_libdir_separator_CXX=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed' + ;; + xl* | mpixl* | bgxl*) + # IBM XL 8.0 on PPC, with GNU ld + hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-dynamic' + archive_cmds_CXX='$CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + if test "x$supports_anon_versioning" = xyes; then + archive_expsym_cmds_CXX='echo "{ global:" > $output_objdir/$libname.ver~ + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' + fi + ;; + *) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) + # Sun C++ 5.9 + no_undefined_flag_CXX=' -zdefs' + archive_cmds_CXX='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + archive_expsym_cmds_CXX='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file ${wl}$export_symbols' + hardcode_libdir_flag_spec_CXX='-R$libdir' + whole_archive_flag_spec_CXX='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + compiler_needs_object_CXX=yes + + # Not sure whether something based on + # $CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 + # would be better. + output_verbose_link_cmd='func_echo_all' + + # Archives containing C++ object files must be created using + # "CC -xar", where "CC" is the Sun C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + old_archive_cmds_CXX='$CC -xar -o $oldlib $oldobjs' + ;; + esac + ;; + esac + ;; + + lynxos*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + + m88k*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + + mvs*) + case $cc_basename in + cxx*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + + netbsd*) + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + archive_cmds_CXX='$LD -Bshareable -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags' + wlarc= + hardcode_libdir_flag_spec_CXX='-R$libdir' + hardcode_direct_CXX=yes + hardcode_shlibpath_var_CXX=no + fi + # Workaround some broken pre-1.5 toolchains + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"' + ;; + + *nto* | *qnx*) + ld_shlibs_CXX=yes + ;; + + openbsd2*) + # C++ shared libraries are fairly broken + ld_shlibs_CXX=no + ;; + + openbsd*) + if test -f /usr/libexec/ld.so; then + hardcode_direct_CXX=yes + hardcode_shlibpath_var_CXX=no + hardcode_direct_absolute_CXX=yes + archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' + hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib' + export_dynamic_flag_spec_CXX='${wl}-E' + whole_archive_flag_spec_CXX="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + fi + output_verbose_link_cmd=func_echo_all + else + ld_shlibs_CXX=no + fi + ;; + + osf3* | osf4* | osf5*) + case $cc_basename in + KCC*) + # Kuck and Associates, Inc. (KAI) C++ Compiler + + # KCC will only create a shared library if the output file + # ends with ".so" (or ".sl" for HP-UX), so rename the library + # to its proper name (with version) after linking. + archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + + hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' + hardcode_libdir_separator_CXX=: + + # Archives containing C++ object files must be created using + # the KAI C++ compiler. + case $host in + osf3*) old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs' ;; + *) old_archive_cmds_CXX='$CC -o $oldlib $oldobjs' ;; + esac + ;; + RCC*) + # Rational C++ 2.4.1 + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + cxx*) + case $host in + osf3*) + allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds_CXX='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && func_echo_all "${wl}-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' + ;; + *) + allow_undefined_flag_CXX=' -expect_unresolved \*' + archive_cmds_CXX='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + archive_expsym_cmds_CXX='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~ + echo "-hidden">> $lib.exp~ + $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname ${wl}-input ${wl}$lib.exp `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~ + $RM $lib.exp' + hardcode_libdir_flag_spec_CXX='-rpath $libdir' + ;; + esac + + hardcode_libdir_separator_CXX=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + ;; + *) + if test "$GXX" = yes && test "$with_gnu_ld" = no; then + allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*' + case $host in + osf3*) + archive_cmds_CXX='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + ;; + *) + archive_cmds_CXX='$CC -shared $pic_flag -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + ;; + esac + + hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_CXX=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + + else + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + fi + ;; + esac + ;; + + psos*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + + sunos4*) + case $cc_basename in + CC*) + # Sun C++ 4.x + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + lcc*) + # Lucid + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + + solaris*) + case $cc_basename in + CC* | sunCC*) + # Sun C++ 4.2, 5.x and Centerline C++ + archive_cmds_need_lc_CXX=yes + no_undefined_flag_CXX=' -zdefs' + archive_cmds_CXX='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -G${allow_undefined_flag} ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' + + hardcode_libdir_flag_spec_CXX='-R$libdir' + hardcode_shlibpath_var_CXX=no + case $host_os in + solaris2.[0-5] | solaris2.[0-5].*) ;; + *) + # The compiler driver will combine and reorder linker options, + # but understands `-z linker_flag'. + # Supported since Solaris 2.6 (maybe 2.5.1?) + whole_archive_flag_spec_CXX='-z allextract$convenience -z defaultextract' + ;; + esac + link_all_deplibs_CXX=yes + + output_verbose_link_cmd='func_echo_all' + + # Archives containing C++ object files must be created using + # "CC -xar", where "CC" is the Sun C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + old_archive_cmds_CXX='$CC -xar -o $oldlib $oldobjs' + ;; + gcx*) + # Green Hills C++ Compiler + archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + + # The C++ compiler must be used to create the archive. + old_archive_cmds_CXX='$CC $LDFLAGS -archive -o $oldlib $oldobjs' + ;; + *) + # GNU C++ compiler with Solaris linker + if test "$GXX" = yes && test "$with_gnu_ld" = no; then + no_undefined_flag_CXX=' ${wl}-z ${wl}defs' + if $CC --version | $GREP -v '^2\.7' > /dev/null; then + archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -shared $pic_flag -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + else + # g++ 2.7 appears to require `-G' NOT `-shared' on this + # platform. + archive_cmds_CXX='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + fi + + hardcode_libdir_flag_spec_CXX='${wl}-R $wl$libdir' + case $host_os in + solaris2.[0-5] | solaris2.[0-5].*) ;; + *) + whole_archive_flag_spec_CXX='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' + ;; + esac + fi + ;; + esac + ;; + + sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*) + no_undefined_flag_CXX='${wl}-z,text' + archive_cmds_need_lc_CXX=no + hardcode_shlibpath_var_CXX=no + runpath_var='LD_RUN_PATH' + + case $cc_basename in + CC*) + archive_cmds_CXX='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds_CXX='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + archive_cmds_CXX='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds_CXX='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + ;; + + sysv5* | sco3.2v5* | sco5v6*) + # Note: We can NOT use -z defs as we might desire, because we do not + # link with -lc, and that would cause any symbols used from libc to + # always be unresolved, which means just about no library would + # ever link correctly. If we're not using GNU ld we use -z text + # though, which does catch some bad symbols but isn't as heavy-handed + # as -z defs. + no_undefined_flag_CXX='${wl}-z,text' + allow_undefined_flag_CXX='${wl}-z,nodefs' + archive_cmds_need_lc_CXX=no + hardcode_shlibpath_var_CXX=no + hardcode_libdir_flag_spec_CXX='${wl}-R,$libdir' + hardcode_libdir_separator_CXX=':' + link_all_deplibs_CXX=yes + export_dynamic_flag_spec_CXX='${wl}-Bexport' + runpath_var='LD_RUN_PATH' + + case $cc_basename in + CC*) + archive_cmds_CXX='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds_CXX='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + old_archive_cmds_CXX='$CC -Tprelink_objects $oldobjs~ + '"$old_archive_cmds_CXX" + reload_cmds_CXX='$CC -Tprelink_objects $reload_objs~ + '"$reload_cmds_CXX" + ;; + *) + archive_cmds_CXX='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds_CXX='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + ;; + + tandem*) + case $cc_basename in + NCC*) + # NonStop-UX NCC 3.20 + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + + vxworks*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5 +$as_echo "$ld_shlibs_CXX" >&6; } + test "$ld_shlibs_CXX" = no && can_build_shared=no + + GCC_CXX="$GXX" + LD_CXX="$LD" + + ## CAVEAT EMPTOR: + ## There is no encapsulation within the following macros, do not change + ## the running order or otherwise move them around unless you know exactly + ## what you are doing... + # Dependencies to place before and after the object being linked: +predep_objects_CXX= +postdep_objects_CXX= +predeps_CXX= +postdeps_CXX= +compiler_lib_search_path_CXX= + +cat > conftest.$ac_ext <<_LT_EOF +class Foo +{ +public: + Foo (void) { a = 0; } +private: + int a; +}; +_LT_EOF + + +_lt_libdeps_save_CFLAGS=$CFLAGS +case "$CC $CFLAGS " in #( +*\ -flto*\ *) CFLAGS="$CFLAGS -fno-lto" ;; +*\ -fwhopr*\ *) CFLAGS="$CFLAGS -fno-whopr" ;; +*\ -fuse-linker-plugin*\ *) CFLAGS="$CFLAGS -fno-use-linker-plugin" ;; +esac + +if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + # Parse the compiler output and extract the necessary + # objects, libraries and library flags. + + # Sentinel used to keep track of whether or not we are before + # the conftest object file. + pre_test_object_deps_done=no + + for p in `eval "$output_verbose_link_cmd"`; do + case ${prev}${p} in + + -L* | -R* | -l*) + # Some compilers place space between "-{L,R}" and the path. + # Remove the space. + if test $p = "-L" || + test $p = "-R"; then + prev=$p + continue + fi + + # Expand the sysroot to ease extracting the directories later. + if test -z "$prev"; then + case $p in + -L*) func_stripname_cnf '-L' '' "$p"; prev=-L; p=$func_stripname_result ;; + -R*) func_stripname_cnf '-R' '' "$p"; prev=-R; p=$func_stripname_result ;; + -l*) func_stripname_cnf '-l' '' "$p"; prev=-l; p=$func_stripname_result ;; + esac + fi + case $p in + =*) func_stripname_cnf '=' '' "$p"; p=$lt_sysroot$func_stripname_result ;; + esac + if test "$pre_test_object_deps_done" = no; then + case ${prev} in + -L | -R) + # Internal compiler library paths should come after those + # provided the user. The postdeps already come after the + # user supplied libs so there is no need to process them. + if test -z "$compiler_lib_search_path_CXX"; then + compiler_lib_search_path_CXX="${prev}${p}" + else + compiler_lib_search_path_CXX="${compiler_lib_search_path_CXX} ${prev}${p}" + fi + ;; + # The "-l" case would never come before the object being + # linked, so don't bother handling this case. + esac + else + if test -z "$postdeps_CXX"; then + postdeps_CXX="${prev}${p}" + else + postdeps_CXX="${postdeps_CXX} ${prev}${p}" + fi + fi + prev= + ;; + + *.lto.$objext) ;; # Ignore GCC LTO objects + *.$objext) + # This assumes that the test object file only shows up + # once in the compiler output. + if test "$p" = "conftest.$objext"; then + pre_test_object_deps_done=yes + continue + fi + + if test "$pre_test_object_deps_done" = no; then + if test -z "$predep_objects_CXX"; then + predep_objects_CXX="$p" + else + predep_objects_CXX="$predep_objects_CXX $p" + fi + else + if test -z "$postdep_objects_CXX"; then + postdep_objects_CXX="$p" + else + postdep_objects_CXX="$postdep_objects_CXX $p" + fi + fi + ;; + + *) ;; # Ignore the rest. + + esac + done + + # Clean up. + rm -f a.out a.exe +else + echo "libtool.m4: error: problem compiling CXX test program" +fi + +$RM -f confest.$objext +CFLAGS=$_lt_libdeps_save_CFLAGS + +# PORTME: override above test on systems where it is broken +case $host_os in +interix[3-9]*) + # Interix 3.5 installs completely hosed .la files for C++, so rather than + # hack all around it, let's just trust "g++" to DTRT. + predep_objects_CXX= + postdep_objects_CXX= + postdeps_CXX= + ;; + +linux*) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) + # Sun C++ 5.9 + + # The more standards-conforming stlport4 library is + # incompatible with the Cstd library. Avoid specifying + # it if it's in CXXFLAGS. Ignore libCrun as + # -library=stlport4 depends on it. + case " $CXX $CXXFLAGS " in + *" -library=stlport4 "*) + solaris_use_stlport4=yes + ;; + esac + + if test "$solaris_use_stlport4" != yes; then + postdeps_CXX='-library=Cstd -library=Crun' + fi + ;; + esac + ;; + +solaris*) + case $cc_basename in + CC* | sunCC*) + # The more standards-conforming stlport4 library is + # incompatible with the Cstd library. Avoid specifying + # it if it's in CXXFLAGS. Ignore libCrun as + # -library=stlport4 depends on it. + case " $CXX $CXXFLAGS " in + *" -library=stlport4 "*) + solaris_use_stlport4=yes + ;; + esac + + # Adding this requires a known-good setup of shared libraries for + # Sun compiler versions before 5.6, else PIC objects from an old + # archive will be linked into the output, leading to subtle bugs. + if test "$solaris_use_stlport4" != yes; then + postdeps_CXX='-library=Cstd -library=Crun' + fi + ;; + esac + ;; +esac + + +case " $postdeps_CXX " in +*" -lc "*) archive_cmds_need_lc_CXX=no ;; +esac + compiler_lib_search_dirs_CXX= +if test -n "${compiler_lib_search_path_CXX}"; then + compiler_lib_search_dirs_CXX=`echo " ${compiler_lib_search_path_CXX}" | ${SED} -e 's! -L! !g' -e 's!^ !!'` +fi + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + lt_prog_compiler_wl_CXX= +lt_prog_compiler_pic_CXX= +lt_prog_compiler_static_CXX= + + + # C++ specific cases for pic, static, wl, etc. + if test "$GXX" = yes; then + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_static_CXX='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static_CXX='-Bstatic' + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + lt_prog_compiler_pic_CXX='-fPIC' + ;; + m68k) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the `-m68020' flag to GCC prevents building anything better, + # like `-m68040'. + lt_prog_compiler_pic_CXX='-m68020 -resident32 -malways-restore-a4' + ;; + esac + ;; + + beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + mingw* | cygwin* | os2* | pw32* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + # Although the cygwin gcc ignores -fPIC, still need this for old-style + # (--disable-auto-import) libraries + lt_prog_compiler_pic_CXX='-DDLL_EXPORT' + ;; + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + lt_prog_compiler_pic_CXX='-fno-common' + ;; + *djgpp*) + # DJGPP does not support shared libraries at all + lt_prog_compiler_pic_CXX= + ;; + haiku*) + # PIC is the default for Haiku. + # The "-static" flag exists, but is broken. + lt_prog_compiler_static_CXX= + ;; + interix[3-9]*) + # Interix 3.x gcc -fpic/-fPIC options generate broken code. + # Instead, we relocate shared libraries at runtime. + ;; + sysv4*MP*) + if test -d /usr/nec; then + lt_prog_compiler_pic_CXX=-Kconform_pic + fi + ;; + hpux*) + # PIC is the default for 64-bit PA HP-UX, but not for 32-bit + # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag + # sets the default TLS model and affects inlining. + case $host_cpu in + hppa*64*) + ;; + *) + lt_prog_compiler_pic_CXX='-fPIC' + ;; + esac + ;; + *qnx* | *nto*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + lt_prog_compiler_pic_CXX='-fPIC -shared' + ;; + *) + lt_prog_compiler_pic_CXX='-fPIC' + ;; + esac + else + case $host_os in + aix[4-9]*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static_CXX='-Bstatic' + else + lt_prog_compiler_static_CXX='-bnso -bI:/lib/syscalls.exp' + fi + ;; + chorus*) + case $cc_basename in + cxch68*) + # Green Hills C++ Compiler + # _LT_TAGVAR(lt_prog_compiler_static, CXX)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a" + ;; + esac + ;; + mingw* | cygwin* | os2* | pw32* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + lt_prog_compiler_pic_CXX='-DDLL_EXPORT' + ;; + dgux*) + case $cc_basename in + ec++*) + lt_prog_compiler_pic_CXX='-KPIC' + ;; + ghcx*) + # Green Hills C++ Compiler + lt_prog_compiler_pic_CXX='-pic' + ;; + *) + ;; + esac + ;; + freebsd* | dragonfly*) + # FreeBSD uses GNU C++ + ;; + hpux9* | hpux10* | hpux11*) + case $cc_basename in + CC*) + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_static_CXX='${wl}-a ${wl}archive' + if test "$host_cpu" != ia64; then + lt_prog_compiler_pic_CXX='+Z' + fi + ;; + aCC*) + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_static_CXX='${wl}-a ${wl}archive' + case $host_cpu in + hppa*64*|ia64*) + # +Z the default + ;; + *) + lt_prog_compiler_pic_CXX='+Z' + ;; + esac + ;; + *) + ;; + esac + ;; + interix*) + # This is c89, which is MS Visual C++ (no shared libs) + # Anyone wants to do a port? + ;; + irix5* | irix6* | nonstopux*) + case $cc_basename in + CC*) + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_static_CXX='-non_shared' + # CC pic flag -KPIC is the default. + ;; + *) + ;; + esac + ;; + linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + case $cc_basename in + KCC*) + # KAI C++ Compiler + lt_prog_compiler_wl_CXX='--backend -Wl,' + lt_prog_compiler_pic_CXX='-fPIC' + ;; + ecpc* ) + # old Intel C++ for x86_64 which still supported -KPIC. + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_pic_CXX='-KPIC' + lt_prog_compiler_static_CXX='-static' + ;; + icpc* ) + # Intel C++, used to be incompatible with GCC. + # ICC 10 doesn't accept -KPIC any more. + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_pic_CXX='-fPIC' + lt_prog_compiler_static_CXX='-static' + ;; + pgCC* | pgcpp*) + # Portland Group C++ compiler + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_pic_CXX='-fpic' + lt_prog_compiler_static_CXX='-Bstatic' + ;; + cxx*) + # Compaq C++ + # Make sure the PIC flag is empty. It appears that all Alpha + # Linux and Compaq Tru64 Unix objects are PIC. + lt_prog_compiler_pic_CXX= + lt_prog_compiler_static_CXX='-non_shared' + ;; + xlc* | xlC* | bgxl[cC]* | mpixl[cC]*) + # IBM XL 8.0, 9.0 on PPC and BlueGene + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_pic_CXX='-qpic' + lt_prog_compiler_static_CXX='-qstaticlink' + ;; + *) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) + # Sun C++ 5.9 + lt_prog_compiler_pic_CXX='-KPIC' + lt_prog_compiler_static_CXX='-Bstatic' + lt_prog_compiler_wl_CXX='-Qoption ld ' + ;; + esac + ;; + esac + ;; + lynxos*) + ;; + m88k*) + ;; + mvs*) + case $cc_basename in + cxx*) + lt_prog_compiler_pic_CXX='-W c,exportall' + ;; + *) + ;; + esac + ;; + netbsd* | netbsdelf*-gnu) + ;; + *qnx* | *nto*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + lt_prog_compiler_pic_CXX='-fPIC -shared' + ;; + osf3* | osf4* | osf5*) + case $cc_basename in + KCC*) + lt_prog_compiler_wl_CXX='--backend -Wl,' + ;; + RCC*) + # Rational C++ 2.4.1 + lt_prog_compiler_pic_CXX='-pic' + ;; + cxx*) + # Digital/Compaq C++ + lt_prog_compiler_wl_CXX='-Wl,' + # Make sure the PIC flag is empty. It appears that all Alpha + # Linux and Compaq Tru64 Unix objects are PIC. + lt_prog_compiler_pic_CXX= + lt_prog_compiler_static_CXX='-non_shared' + ;; + *) + ;; + esac + ;; + psos*) + ;; + solaris*) + case $cc_basename in + CC* | sunCC*) + # Sun C++ 4.2, 5.x and Centerline C++ + lt_prog_compiler_pic_CXX='-KPIC' + lt_prog_compiler_static_CXX='-Bstatic' + lt_prog_compiler_wl_CXX='-Qoption ld ' + ;; + gcx*) + # Green Hills C++ Compiler + lt_prog_compiler_pic_CXX='-PIC' + ;; + *) + ;; + esac + ;; + sunos4*) + case $cc_basename in + CC*) + # Sun C++ 4.x + lt_prog_compiler_pic_CXX='-pic' + lt_prog_compiler_static_CXX='-Bstatic' + ;; + lcc*) + # Lucid + lt_prog_compiler_pic_CXX='-pic' + ;; + *) + ;; + esac + ;; + sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) + case $cc_basename in + CC*) + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_pic_CXX='-KPIC' + lt_prog_compiler_static_CXX='-Bstatic' + ;; + esac + ;; + tandem*) + case $cc_basename in + NCC*) + # NonStop-UX NCC 3.20 + lt_prog_compiler_pic_CXX='-KPIC' + ;; + *) + ;; + esac + ;; + vxworks*) + ;; + *) + lt_prog_compiler_can_build_shared_CXX=no + ;; + esac + fi + +case $host_os in + # For platforms which do not support PIC, -DPIC is meaningless: + *djgpp*) + lt_prog_compiler_pic_CXX= + ;; + *) + lt_prog_compiler_pic_CXX="$lt_prog_compiler_pic_CXX -DPIC" + ;; +esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 +$as_echo_n "checking for $compiler option to produce PIC... " >&6; } +if ${lt_cv_prog_compiler_pic_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_pic_CXX=$lt_prog_compiler_pic_CXX +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_CXX" >&5 +$as_echo "$lt_cv_prog_compiler_pic_CXX" >&6; } +lt_prog_compiler_pic_CXX=$lt_cv_prog_compiler_pic_CXX + +# +# Check to make sure the PIC flag actually works. +# +if test -n "$lt_prog_compiler_pic_CXX"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works" >&5 +$as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works... " >&6; } +if ${lt_cv_prog_compiler_pic_works_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_pic_works_CXX=no + ac_outfile=conftest.$ac_objext + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="$lt_prog_compiler_pic_CXX -DPIC" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings other than the usual output. + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then + lt_cv_prog_compiler_pic_works_CXX=yes + fi + fi + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works_CXX" >&5 +$as_echo "$lt_cv_prog_compiler_pic_works_CXX" >&6; } + +if test x"$lt_cv_prog_compiler_pic_works_CXX" = xyes; then + case $lt_prog_compiler_pic_CXX in + "" | " "*) ;; + *) lt_prog_compiler_pic_CXX=" $lt_prog_compiler_pic_CXX" ;; + esac +else + lt_prog_compiler_pic_CXX= + lt_prog_compiler_can_build_shared_CXX=no +fi + +fi + + + + + +# +# Check to make sure the static flag actually works. +# +wl=$lt_prog_compiler_wl_CXX eval lt_tmp_static_flag=\"$lt_prog_compiler_static_CXX\" +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5 +$as_echo_n "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; } +if ${lt_cv_prog_compiler_static_works_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_static_works_CXX=no + save_LDFLAGS="$LDFLAGS" + LDFLAGS="$LDFLAGS $lt_tmp_static_flag" + echo "$lt_simple_link_test_code" > conftest.$ac_ext + if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then + # The linker can only warn and ignore the option if not recognized + # So say no if there are warnings + if test -s conftest.err; then + # Append any errors to the config.log. + cat conftest.err 1>&5 + $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if diff conftest.exp conftest.er2 >/dev/null; then + lt_cv_prog_compiler_static_works_CXX=yes + fi + else + lt_cv_prog_compiler_static_works_CXX=yes + fi + fi + $RM -r conftest* + LDFLAGS="$save_LDFLAGS" + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works_CXX" >&5 +$as_echo "$lt_cv_prog_compiler_static_works_CXX" >&6; } + +if test x"$lt_cv_prog_compiler_static_works_CXX" = xyes; then + : +else + lt_prog_compiler_static_CXX= +fi + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 +$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } +if ${lt_cv_prog_compiler_c_o_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_c_o_CXX=no + $RM -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp + $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 + if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then + lt_cv_prog_compiler_c_o_CXX=yes + fi + fi + chmod u+w . 2>&5 + $RM conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files + $RM out/* && rmdir out + cd .. + $RM -r conftest + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5 +$as_echo "$lt_cv_prog_compiler_c_o_CXX" >&6; } + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 +$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } +if ${lt_cv_prog_compiler_c_o_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_c_o_CXX=no + $RM -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp + $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 + if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then + lt_cv_prog_compiler_c_o_CXX=yes + fi + fi + chmod u+w . 2>&5 + $RM conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files + $RM out/* && rmdir out + cd .. + $RM -r conftest + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5 +$as_echo "$lt_cv_prog_compiler_c_o_CXX" >&6; } + + + + +hard_links="nottested" +if test "$lt_cv_prog_compiler_c_o_CXX" = no && test "$need_locks" != no; then + # do not overwrite the value of need_locks provided by the user + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 +$as_echo_n "checking if we can lock with hard links... " >&6; } + hard_links=yes + $RM conftest* + ln conftest.a conftest.b 2>/dev/null && hard_links=no + touch conftest.a + ln conftest.a conftest.b 2>&5 || hard_links=no + ln conftest.a conftest.b 2>/dev/null && hard_links=no + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 +$as_echo "$hard_links" >&6; } + if test "$hard_links" = no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5 +$as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;} + need_locks=warn + fi +else + need_locks=no +fi + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 +$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } + + export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + exclude_expsyms_CXX='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*' + case $host_os in + aix[4-9]*) + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to AIX nm, but means don't demangle with GNU nm + # Also, AIX nm treats weak defined symbols like other global defined + # symbols, whereas GNU nm marks them as "W". + if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then + export_symbols_cmds_CXX='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + else + export_symbols_cmds_CXX='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + fi + ;; + pw32*) + export_symbols_cmds_CXX="$ltdll_cmds" + ;; + cygwin* | mingw* | cegcc*) + case $cc_basename in + cl*) + exclude_expsyms_CXX='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*' + ;; + *) + export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1 DATA/;s/^.*[ ]__nm__\([^ ]*\)[ ][^ ]*/\1 DATA/;/^I[ ]/d;/^[AITW][ ]/s/.* //'\'' | sort | uniq > $export_symbols' + exclude_expsyms_CXX='[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname' + ;; + esac + ;; + linux* | k*bsd*-gnu | gnu*) + link_all_deplibs_CXX=no + ;; + *) + export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + ;; + esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5 +$as_echo "$ld_shlibs_CXX" >&6; } +test "$ld_shlibs_CXX" = no && can_build_shared=no + +with_gnu_ld_CXX=$with_gnu_ld + + + + + + +# +# Do we need to explicitly link libc? +# +case "x$archive_cmds_need_lc_CXX" in +x|xyes) + # Assume -lc should be added + archive_cmds_need_lc_CXX=yes + + if test "$enable_shared" = yes && test "$GCC" = yes; then + case $archive_cmds_CXX in + *'~'*) + # FIXME: we may have to deal with multi-command sequences. + ;; + '$CC '*) + # Test whether the compiler implicitly links with -lc since on some + # systems, -lgcc has to come before -lc. If gcc already passes -lc + # to ld, don't add -lc before -lgcc. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 +$as_echo_n "checking whether -lc should be explicitly linked in... " >&6; } +if ${lt_cv_archive_cmds_need_lc_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + $RM conftest* + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } 2>conftest.err; then + soname=conftest + lib=conftest + libobjs=conftest.$ac_objext + deplibs= + wl=$lt_prog_compiler_wl_CXX + pic_flag=$lt_prog_compiler_pic_CXX + compiler_flags=-v + linker_flags=-v + verstring= + output_objdir=. + libname=conftest + lt_save_allow_undefined_flag=$allow_undefined_flag_CXX + allow_undefined_flag_CXX= + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds_CXX 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5 + (eval $archive_cmds_CXX 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + then + lt_cv_archive_cmds_need_lc_CXX=no + else + lt_cv_archive_cmds_need_lc_CXX=yes + fi + allow_undefined_flag_CXX=$lt_save_allow_undefined_flag + else + cat conftest.err 1>&5 + fi + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc_CXX" >&5 +$as_echo "$lt_cv_archive_cmds_need_lc_CXX" >&6; } + archive_cmds_need_lc_CXX=$lt_cv_archive_cmds_need_lc_CXX + ;; + esac + fi + ;; +esac + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 +$as_echo_n "checking dynamic linker characteristics... " >&6; } + +library_names_spec= +libname_spec='lib$name' +soname_spec= +shrext_cmds=".so" +postinstall_cmds= +postuninstall_cmds= +finish_cmds= +finish_eval= +shlibpath_var= +shlibpath_overrides_runpath=unknown +version_type=none +dynamic_linker="$host_os ld.so" +sys_lib_dlsearch_path_spec="/lib /usr/lib" +need_lib_prefix=unknown +hardcode_into_libs=no + +# when you set need_version to no, make sure it does not cause -set_version +# flags to be left without arguments +need_version=unknown + +case $host_os in +aix3*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' + shlibpath_var=LIBPATH + + # AIX 3 has no versioning support, so we append a major version to the name. + soname_spec='${libname}${release}${shared_ext}$major' + ;; + +aix[4-9]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + hardcode_into_libs=yes + if test "$host_cpu" = ia64; then + # AIX 5 supports IA64 + library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + else + # With GCC up to 2.95.x, collect2 would create an import file + # for dependence libraries. The import file would start with + # the line `#! .'. This would cause the generated library to + # depend on `.', always an invalid library. This was fixed in + # development snapshots of GCC prior to 3.0. + case $host_os in + aix4 | aix4.[01] | aix4.[01].*) + if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' + echo ' yes ' + echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then + : + else + can_build_shared=no + fi + ;; + esac + # AIX (on Power*) has no versioning support, so currently we can not hardcode correct + # soname into executable. Probably we can add versioning support to + # collect2, so additional links can be useful in future. + if test "$aix_use_runtimelinking" = yes; then + # If using run time linking (on AIX 4.2 or later) use lib.so + # instead of lib.a to let people know that these are not + # typical AIX shared libraries. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + else + # We preserve .a as extension for shared libraries through AIX4.2 + # and later when we are not doing run time linking. + library_names_spec='${libname}${release}.a $libname.a' + soname_spec='${libname}${release}${shared_ext}$major' + fi + shlibpath_var=LIBPATH + fi + ;; + +amigaos*) + case $host_cpu in + powerpc) + # Since July 2007 AmigaOS4 officially supports .so libraries. + # When compiling the executable, add -use-dynld -Lsobjs: to the compileline. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + ;; + m68k) + library_names_spec='$libname.ixlibrary $libname.a' + # Create ${libname}_ixlibrary.a entries in /sys/libs. + finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' + ;; + esac + ;; + +beos*) + library_names_spec='${libname}${shared_ext}' + dynamic_linker="$host_os ld.so" + shlibpath_var=LIBRARY_PATH + ;; + +bsdi[45]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" + sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" + # the default ld.so.conf also contains /usr/contrib/lib and + # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow + # libtool to hard-code these into programs + ;; + +cygwin* | mingw* | pw32* | cegcc*) + version_type=windows + shrext_cmds=".dll" + need_version=no + need_lib_prefix=no + + case $GCC,$cc_basename in + yes,*) + # gcc + library_names_spec='$libname.dll.a' + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname~ + chmod a+x \$dldir/$dlname~ + if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then + eval '\''$striplib \$dldir/$dlname'\'' || exit \$?; + fi' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $RM \$dlpath' + shlibpath_overrides_runpath=yes + + case $host_os in + cygwin*) + # Cygwin DLLs use 'cyg' prefix rather than 'lib' + soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + + ;; + mingw* | cegcc*) + # MinGW DLLs use traditional 'lib' prefix + soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + ;; + pw32*) + # pw32 DLLs use 'pw' prefix rather than 'lib' + library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + ;; + esac + dynamic_linker='Win32 ld.exe' + ;; + + *,cl*) + # Native MSVC + libname_spec='$name' + soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + library_names_spec='${libname}.dll.lib' + + case $build_os in + mingw*) + sys_lib_search_path_spec= + lt_save_ifs=$IFS + IFS=';' + for lt_path in $LIB + do + IFS=$lt_save_ifs + # Let DOS variable expansion print the short 8.3 style file name. + lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"` + sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path" + done + IFS=$lt_save_ifs + # Convert to MSYS style. + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'` + ;; + cygwin*) + # Convert to unix form, then to dos form, then back to unix form + # but this time dos style (no spaces!) so that the unix form looks + # like /cygdrive/c/PROGRA~1:/cygdr... + sys_lib_search_path_spec=`cygpath --path --unix "$LIB"` + sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null` + sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + ;; + *) + sys_lib_search_path_spec="$LIB" + if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then + # It is most probably a Windows format PATH. + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi + # FIXME: find the short name or the path components, as spaces are + # common. (e.g. "Program Files" -> "PROGRA~1") + ;; + esac + + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $RM \$dlpath' + shlibpath_overrides_runpath=yes + dynamic_linker='Win32 link.exe' + ;; + + *) + # Assume MSVC wrapper + library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib' + dynamic_linker='Win32 ld.exe' + ;; + esac + # FIXME: first we should search . and the directory the executable is in + shlibpath_var=PATH + ;; + +darwin* | rhapsody*) + dynamic_linker="$host_os dyld" + version_type=darwin + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext' + soname_spec='${libname}${release}${major}$shared_ext' + shlibpath_overrides_runpath=yes + shlibpath_var=DYLD_LIBRARY_PATH + shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`' + + sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib' + ;; + +dgux*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +freebsd* | dragonfly*) + # DragonFly does not have aout. When/if they implement a new + # versioning mechanism, adjust this. + if test -x /usr/bin/objformat; then + objformat=`/usr/bin/objformat` + else + case $host_os in + freebsd[23].*) objformat=aout ;; + *) objformat=elf ;; + esac + fi + version_type=freebsd-$objformat + case $version_type in + freebsd-elf*) + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + need_version=no + need_lib_prefix=no + ;; + freebsd-*) + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' + need_version=yes + ;; + esac + shlibpath_var=LD_LIBRARY_PATH + case $host_os in + freebsd2.*) + shlibpath_overrides_runpath=yes + ;; + freebsd3.[01]* | freebsdelf3.[01]*) + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + freebsd3.[2-9]* | freebsdelf3.[2-9]* | \ + freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1) + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + *) # from 4.6 on, and DragonFly + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + esac + ;; + +haiku*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + dynamic_linker="$host_os runtime_loader" + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LIBRARY_PATH + shlibpath_overrides_runpath=yes + sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib' + hardcode_into_libs=yes + ;; + +hpux9* | hpux10* | hpux11*) + # Give a soname corresponding to the major version so that dld.sl refuses to + # link against other versions. + version_type=sunos + need_lib_prefix=no + need_version=no + case $host_cpu in + ia64*) + shrext_cmds='.so' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.so" + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + if test "X$HPUX_IA64_MODE" = X32; then + sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" + else + sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" + fi + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + hppa*64*) + shrext_cmds='.sl' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.sl" + shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + *) + shrext_cmds='.sl' + dynamic_linker="$host_os dld.sl" + shlibpath_var=SHLIB_PATH + shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + ;; + esac + # HP-UX runs *really* slowly unless shared libraries are mode 555, ... + postinstall_cmds='chmod 555 $lib' + # or fails outright, so override atomically: + install_override_mode=555 + ;; + +interix[3-9]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + +irix5* | irix6* | nonstopux*) + case $host_os in + nonstopux*) version_type=nonstopux ;; + *) + if test "$lt_cv_prog_gnu_ld" = yes; then + version_type=linux # correct to gnu/linux during the next big refactor + else + version_type=irix + fi ;; + esac + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' + case $host_os in + irix5* | nonstopux*) + libsuff= shlibsuff= + ;; + *) + case $LD in # libtool.m4 will add one of these switches to LD + *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") + libsuff= shlibsuff= libmagic=32-bit;; + *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") + libsuff=32 shlibsuff=N32 libmagic=N32;; + *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") + libsuff=64 shlibsuff=64 libmagic=64-bit;; + *) libsuff= shlibsuff= libmagic=never-match;; + esac + ;; + esac + shlibpath_var=LD_LIBRARY${shlibsuff}_PATH + shlibpath_overrides_runpath=no + sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" + sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" + hardcode_into_libs=yes + ;; + +# No shared lib support for Linux oldld, aout, or coff. +linux*oldld* | linux*aout* | linux*coff*) + dynamic_linker=no + ;; + +# This must be glibc/ELF. +linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + + # Some binutils ld are patched to set DT_RUNPATH + if ${lt_cv_shlibpath_overrides_runpath+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_shlibpath_overrides_runpath=no + save_LDFLAGS=$LDFLAGS + save_libdir=$libdir + eval "libdir=/foo; wl=\"$lt_prog_compiler_wl_CXX\"; \ + LDFLAGS=\"\$LDFLAGS $hardcode_libdir_flag_spec_CXX\"" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + if ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null; then : + lt_cv_shlibpath_overrides_runpath=yes +fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + LDFLAGS=$save_LDFLAGS + libdir=$save_libdir + +fi + + shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath + + # This implies no fast_install, which is unacceptable. + # Some rework will be needed to allow for fast_install + # before this can be enabled. + hardcode_into_libs=yes + + # Append ld.so.conf contents to the search path + if test -f /etc/ld.so.conf; then + lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '` + sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra" + fi + + # We used to test for /lib/ld.so.1 and disable shared libraries on + # powerpc, because MkLinux only supported shared libraries with the + # GNU dynamic linker. Since this was broken with cross compilers, + # most powerpc-linux boxes support dynamic linking these days and + # people can always --disable-shared, the test was removed, and we + # assume the GNU/Linux dynamic linker is in use. + dynamic_linker='GNU/Linux ld.so' + ;; + +netbsdelf*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='NetBSD ld.elf_so' + ;; + +netbsd*) + version_type=sunos + need_lib_prefix=no + need_version=no + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + dynamic_linker='NetBSD (a.out) ld.so' + else + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='NetBSD ld.elf_so' + fi + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + +newsos6) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +*nto* | *qnx*) + version_type=qnx + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='ldqnx.so' + ;; + +openbsd*) + version_type=sunos + sys_lib_dlsearch_path_spec="/usr/lib" + need_lib_prefix=no + # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs. + case $host_os in + openbsd3.3 | openbsd3.3.*) need_version=yes ;; + *) need_version=no ;; + esac + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + shlibpath_var=LD_LIBRARY_PATH + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + case $host_os in + openbsd2.[89] | openbsd2.[89].*) + shlibpath_overrides_runpath=no + ;; + *) + shlibpath_overrides_runpath=yes + ;; + esac + else + shlibpath_overrides_runpath=yes + fi + ;; + +os2*) + libname_spec='$name' + shrext_cmds=".dll" + need_lib_prefix=no + library_names_spec='$libname${shared_ext} $libname.a' + dynamic_linker='OS/2 ld.exe' + shlibpath_var=LIBPATH + ;; + +osf3* | osf4* | osf5*) + version_type=osf + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" + sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" + ;; + +rdos*) + dynamic_linker=no + ;; + +solaris*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + # ldd complains unless libraries are executable + postinstall_cmds='chmod +x $lib' + ;; + +sunos4*) + version_type=sunos + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + if test "$with_gnu_ld" = yes; then + need_lib_prefix=no + fi + need_version=yes + ;; + +sysv4 | sysv4.3*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + case $host_vendor in + sni) + shlibpath_overrides_runpath=no + need_lib_prefix=no + runpath_var=LD_RUN_PATH + ;; + siemens) + need_lib_prefix=no + ;; + motorola) + need_lib_prefix=no + need_version=no + shlibpath_overrides_runpath=no + sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' + ;; + esac + ;; + +sysv4*MP*) + if test -d /usr/nec ;then + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' + soname_spec='$libname${shared_ext}.$major' + shlibpath_var=LD_LIBRARY_PATH + fi + ;; + +sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) + version_type=freebsd-elf + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + if test "$with_gnu_ld" = yes; then + sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib' + else + sys_lib_search_path_spec='/usr/ccs/lib /usr/lib' + case $host_os in + sco3.2v5*) + sys_lib_search_path_spec="$sys_lib_search_path_spec /lib" + ;; + esac + fi + sys_lib_dlsearch_path_spec='/usr/lib' + ;; + +tpf*) + # TPF is a cross-target only. Preferred cross-host = GNU/Linux. + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + +uts4*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +*) + dynamic_linker=no + ;; +esac +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 +$as_echo "$dynamic_linker" >&6; } +test "$dynamic_linker" = no && can_build_shared=no + +variables_saved_for_relink="PATH $shlibpath_var $runpath_var" +if test "$GCC" = yes; then + variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" +fi + +if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then + sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec" +fi +if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then + sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec" +fi + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 +$as_echo_n "checking how to hardcode library paths into programs... " >&6; } +hardcode_action_CXX= +if test -n "$hardcode_libdir_flag_spec_CXX" || + test -n "$runpath_var_CXX" || + test "X$hardcode_automatic_CXX" = "Xyes" ; then + + # We can hardcode non-existent directories. + if test "$hardcode_direct_CXX" != no && + # If the only mechanism to avoid hardcoding is shlibpath_var, we + # have to relink, otherwise we might link with an installed library + # when we should be linking with a yet-to-be-installed one + ## test "$_LT_TAGVAR(hardcode_shlibpath_var, CXX)" != no && + test "$hardcode_minus_L_CXX" != no; then + # Linking always hardcodes the temporary library directory. + hardcode_action_CXX=relink + else + # We can link without hardcoding, and we can hardcode nonexisting dirs. + hardcode_action_CXX=immediate + fi +else + # We cannot hardcode anything, or else we can only hardcode existing + # directories. + hardcode_action_CXX=unsupported +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action_CXX" >&5 +$as_echo "$hardcode_action_CXX" >&6; } + +if test "$hardcode_action_CXX" = relink || + test "$inherit_rpath_CXX" = yes; then + # Fast installation is not supported + enable_fast_install=no +elif test "$shlibpath_overrides_runpath" = yes || + test "$enable_shared" = no; then + # Fast installation is not necessary + enable_fast_install=needless +fi + + + + + + + + fi # test -n "$compiler" + + CC=$lt_save_CC + CFLAGS=$lt_save_CFLAGS + LDCXX=$LD + LD=$lt_save_LD + GCC=$lt_save_GCC + with_gnu_ld=$lt_save_with_gnu_ld + lt_cv_path_LDCXX=$lt_cv_path_LD + lt_cv_path_LD=$lt_save_path_LD + lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld + lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld +fi # test "$_lt_caught_CXX_error" != yes + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + + + + + + + + + + + + + + + ac_config_commands="$ac_config_commands libtool" + + + + +# Only expand once: + + + +ac_config_headers="$ac_config_headers config.h src/include/fst/config.h" + + +ac_config_files="$ac_config_files Makefile src/Makefile src/include/Makefile src/lib/Makefile src/bin/Makefile src/test/Makefile src/extensions/Makefile src/extensions/compact/Makefile src/extensions/compress/Makefile src/extensions/const/Makefile src/extensions/far/Makefile src/extensions/linear/Makefile src/extensions/lookahead/Makefile src/extensions/mpdt/Makefile src/extensions/ngram/Makefile src/extensions/pdt/Makefile src/extensions/python/Makefile src/extensions/special/Makefile src/script/Makefile" + + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + +# Check whether --enable-compact-fsts was given. +if test "${enable_compact_fsts+set}" = set; then : + enableval=$enable_compact_fsts; +else + enable_compact_fsts=no +fi + + if test "x$enable_compact_fsts" != xno; then + HAVE_COMPACT_TRUE= + HAVE_COMPACT_FALSE='#' +else + HAVE_COMPACT_TRUE='#' + HAVE_COMPACT_FALSE= +fi + + +# Check whether --enable-compress was given. +if test "${enable_compress+set}" = set; then : + enableval=$enable_compress; +else + enable_compress=no +fi + + if test "x$enable_compress" != xno; then + HAVE_COMPRESS_TRUE= + HAVE_COMPRESS_FALSE='#' +else + HAVE_COMPRESS_TRUE='#' + HAVE_COMPRESS_FALSE= +fi + + +# Check whether --enable-const-fsts was given. +if test "${enable_const_fsts+set}" = set; then : + enableval=$enable_const_fsts; +else + enable_const_fsts=no +fi + + if test "x$enable_const_fsts" != xno; then + HAVE_CONST_TRUE= + HAVE_CONST_FALSE='#' +else + HAVE_CONST_TRUE='#' + HAVE_CONST_FALSE= +fi + + +# Check whether --enable-far was given. +if test "${enable_far+set}" = set; then : + enableval=$enable_far; +else + enable_far=no +fi + + if test "x$enable_far" != xno; then + HAVE_FAR_TRUE= + HAVE_FAR_FALSE='#' +else + HAVE_FAR_TRUE='#' + HAVE_FAR_FALSE= +fi + + +# Check whether --enable-linear-fsts was given. +if test "${enable_linear_fsts+set}" = set; then : + enableval=$enable_linear_fsts; +else + enable_linear_fsts=no +fi + + if test "x$enable_linear_fsts" != xno; then + HAVE_LINEAR_TRUE= + HAVE_LINEAR_FALSE='#' +else + HAVE_LINEAR_TRUE='#' + HAVE_LINEAR_FALSE= +fi + + +# Check whether --enable-lookahead-fsts was given. +if test "${enable_lookahead_fsts+set}" = set; then : + enableval=$enable_lookahead_fsts; +else + enable_lookahead_fsts=no +fi + + if test "x$enable_lookahead_fsts" != xno; then + HAVE_LOOKAHEAD_TRUE= + HAVE_LOOKAHEAD_FALSE='#' +else + HAVE_LOOKAHEAD_TRUE='#' + HAVE_LOOKAHEAD_FALSE= +fi + + +# Check whether --enable-mpdt was given. +if test "${enable_mpdt+set}" = set; then : + enableval=$enable_mpdt; +else + enable_mpdt=no +fi + + if test "x$enable_mpdt" != xno; then + HAVE_MPDT_TRUE= + HAVE_MPDT_FALSE='#' +else + HAVE_MPDT_TRUE='#' + HAVE_MPDT_FALSE= +fi + + +# Check whether --enable-ngram-fsts was given. +if test "${enable_ngram_fsts+set}" = set; then : + enableval=$enable_ngram_fsts; +else + enable_ngram_fsts=no +fi + + if test "x$enable_ngram_fsts" != xno; then + HAVE_NGRAM_TRUE= + HAVE_NGRAM_FALSE='#' +else + HAVE_NGRAM_TRUE='#' + HAVE_NGRAM_FALSE= +fi + + +# Check whether --enable-pdt was given. +if test "${enable_pdt+set}" = set; then : + enableval=$enable_pdt; +else + enable_pdt=no +fi + + if test "x$enable_pdt" != xno; then + HAVE_PDT_TRUE= + HAVE_PDT_FALSE='#' +else + HAVE_PDT_TRUE='#' + HAVE_PDT_FALSE= +fi + + +# Check whether --enable-python was given. +if test "${enable_python+set}" = set; then : + enableval=$enable_python; +else + enable_python=no +fi + + if test "x$enable_python" != xno; then + HAVE_PYTHON_TRUE= + HAVE_PYTHON_FALSE='#' +else + HAVE_PYTHON_TRUE='#' + HAVE_PYTHON_FALSE= +fi + +if test "x$enable_python" != xno; then + + + + + + + if test -n "$PYTHON"; then + # If the user set $PYTHON, use it and don't search something else. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $PYTHON version is >= 2.7" >&5 +$as_echo_n "checking whether $PYTHON version is >= 2.7... " >&6; } + prog="import sys +# split strings by '.' and convert to numeric. Append some zeros +# because we need at least 4 digits for the hex conversion. +# map returns an iterator in Python 3.0 and a list in 2.x +minver = list(map(int, '2.7'.split('.'))) + [0, 0, 0] +minverhex = 0 +# xrange is not present in Python 3.0 and range returns an iterator +for i in list(range(0, 4)): minverhex = (minverhex << 8) + minver[i] +sys.exit(sys.hexversion < minverhex)" + if { echo "$as_me:$LINENO: $PYTHON -c "$prog"" >&5 + ($PYTHON -c "$prog") >&5 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; then : + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + as_fn_error $? "Python interpreter is too old" "$LINENO" 5 +fi + am_display_PYTHON=$PYTHON + else + # Otherwise, try each interpreter until we find one that satisfies + # VERSION. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a Python interpreter with version >= 2.7" >&5 +$as_echo_n "checking for a Python interpreter with version >= 2.7... " >&6; } +if ${am_cv_pathless_PYTHON+:} false; then : + $as_echo_n "(cached) " >&6 +else + + for am_cv_pathless_PYTHON in python python2 python3 python3.3 python3.2 python3.1 python3.0 python2.7 python2.6 python2.5 python2.4 python2.3 python2.2 python2.1 python2.0 none; do + test "$am_cv_pathless_PYTHON" = none && break + prog="import sys +# split strings by '.' and convert to numeric. Append some zeros +# because we need at least 4 digits for the hex conversion. +# map returns an iterator in Python 3.0 and a list in 2.x +minver = list(map(int, '2.7'.split('.'))) + [0, 0, 0] +minverhex = 0 +# xrange is not present in Python 3.0 and range returns an iterator +for i in list(range(0, 4)): minverhex = (minverhex << 8) + minver[i] +sys.exit(sys.hexversion < minverhex)" + if { echo "$as_me:$LINENO: $am_cv_pathless_PYTHON -c "$prog"" >&5 + ($am_cv_pathless_PYTHON -c "$prog") >&5 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; then : + break +fi + done +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_pathless_PYTHON" >&5 +$as_echo "$am_cv_pathless_PYTHON" >&6; } + # Set $PYTHON to the absolute path of $am_cv_pathless_PYTHON. + if test "$am_cv_pathless_PYTHON" = none; then + PYTHON=: + else + # Extract the first word of "$am_cv_pathless_PYTHON", so it can be a program name with args. +set dummy $am_cv_pathless_PYTHON; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_PYTHON+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $PYTHON in + [\\/]* | ?:[\\/]*) + ac_cv_path_PYTHON="$PYTHON" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_path_PYTHON="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +PYTHON=$ac_cv_path_PYTHON +if test -n "$PYTHON"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON" >&5 +$as_echo "$PYTHON" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + fi + am_display_PYTHON=$am_cv_pathless_PYTHON + fi + + + if test "$PYTHON" = :; then + as_fn_error $? "no suitable Python interpreter found" "$LINENO" 5 + else + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON version" >&5 +$as_echo_n "checking for $am_display_PYTHON version... " >&6; } +if ${am_cv_python_version+:} false; then : + $as_echo_n "(cached) " >&6 +else + am_cv_python_version=`$PYTHON -c "import sys; sys.stdout.write(sys.version[:3])"` +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_version" >&5 +$as_echo "$am_cv_python_version" >&6; } + PYTHON_VERSION=$am_cv_python_version + + + + PYTHON_PREFIX='${prefix}' + + PYTHON_EXEC_PREFIX='${exec_prefix}' + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON platform" >&5 +$as_echo_n "checking for $am_display_PYTHON platform... " >&6; } +if ${am_cv_python_platform+:} false; then : + $as_echo_n "(cached) " >&6 +else + am_cv_python_platform=`$PYTHON -c "import sys; sys.stdout.write(sys.platform)"` +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_platform" >&5 +$as_echo "$am_cv_python_platform" >&6; } + PYTHON_PLATFORM=$am_cv_python_platform + + + # Just factor out some code duplication. + am_python_setup_sysconfig="\ +import sys +# Prefer sysconfig over distutils.sysconfig, for better compatibility +# with python 3.x. See automake bug#10227. +try: + import sysconfig +except ImportError: + can_use_sysconfig = 0 +else: + can_use_sysconfig = 1 +# Can't use sysconfig in CPython 2.7, since it's broken in virtualenvs: +# +try: + from platform import python_implementation + if python_implementation() == 'CPython' and sys.version[:3] == '2.7': + can_use_sysconfig = 0 +except ImportError: + pass" + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON script directory" >&5 +$as_echo_n "checking for $am_display_PYTHON script directory... " >&6; } +if ${am_cv_python_pythondir+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "x$prefix" = xNONE + then + am_py_prefix=$ac_default_prefix + else + am_py_prefix=$prefix + fi + am_cv_python_pythondir=`$PYTHON -c " +$am_python_setup_sysconfig +if can_use_sysconfig: + sitedir = sysconfig.get_path('purelib', vars={'base':'$am_py_prefix'}) +else: + from distutils import sysconfig + sitedir = sysconfig.get_python_lib(0, 0, prefix='$am_py_prefix') +sys.stdout.write(sitedir)"` + case $am_cv_python_pythondir in + $am_py_prefix*) + am__strip_prefix=`echo "$am_py_prefix" | sed 's|.|.|g'` + am_cv_python_pythondir=`echo "$am_cv_python_pythondir" | sed "s,^$am__strip_prefix,$PYTHON_PREFIX,"` + ;; + *) + case $am_py_prefix in + /usr|/System*) ;; + *) + am_cv_python_pythondir=$PYTHON_PREFIX/lib/python$PYTHON_VERSION/site-packages + ;; + esac + ;; + esac + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_pythondir" >&5 +$as_echo "$am_cv_python_pythondir" >&6; } + pythondir=$am_cv_python_pythondir + + + + pkgpythondir=\${pythondir}/$PACKAGE + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON extension module directory" >&5 +$as_echo_n "checking for $am_display_PYTHON extension module directory... " >&6; } +if ${am_cv_python_pyexecdir+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "x$exec_prefix" = xNONE + then + am_py_exec_prefix=$am_py_prefix + else + am_py_exec_prefix=$exec_prefix + fi + am_cv_python_pyexecdir=`$PYTHON -c " +$am_python_setup_sysconfig +if can_use_sysconfig: + sitedir = sysconfig.get_path('platlib', vars={'platbase':'$am_py_prefix'}) +else: + from distutils import sysconfig + sitedir = sysconfig.get_python_lib(1, 0, prefix='$am_py_prefix') +sys.stdout.write(sitedir)"` + case $am_cv_python_pyexecdir in + $am_py_exec_prefix*) + am__strip_prefix=`echo "$am_py_exec_prefix" | sed 's|.|.|g'` + am_cv_python_pyexecdir=`echo "$am_cv_python_pyexecdir" | sed "s,^$am__strip_prefix,$PYTHON_EXEC_PREFIX,"` + ;; + *) + case $am_py_exec_prefix in + /usr|/System*) ;; + *) + am_cv_python_pyexecdir=$PYTHON_EXEC_PREFIX/lib/python$PYTHON_VERSION/site-packages + ;; + esac + ;; + esac + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_pyexecdir" >&5 +$as_echo "$am_cv_python_pyexecdir" >&6; } + pyexecdir=$am_cv_python_pyexecdir + + + + pkgpyexecdir=\${pyexecdir}/$PACKAGE + + + + fi + + + + # + # Allow the use of a (user set) custom python version + # + + + # Extract the first word of "python[$PYTHON_VERSION]", so it can be a program name with args. +set dummy python$PYTHON_VERSION; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_PYTHON+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $PYTHON in + [\\/]* | ?:[\\/]*) + ac_cv_path_PYTHON="$PYTHON" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_path_PYTHON="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +PYTHON=$ac_cv_path_PYTHON +if test -n "$PYTHON"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON" >&5 +$as_echo "$PYTHON" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + if test -z "$PYTHON"; then + as_fn_error $? "Cannot find python$PYTHON_VERSION in your system path" "$LINENO" 5 + PYTHON_VERSION="" + fi + + # + # Check for a version of Python >= 2.1.0 + # + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a version of Python >= '2.1.0'" >&5 +$as_echo_n "checking for a version of Python >= '2.1.0'... " >&6; } + ac_supports_python_ver=`$PYTHON -c "import sys, string; \ + ver = string.split(sys.version)[0]; \ + print ver >= '2.1.0'"` + if test "$ac_supports_python_ver" != "True"; then + if test -z "$PYTHON_NOVERSIONCHECK"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? " +This version of the AC_PYTHON_DEVEL macro +doesn't work properly with versions of Python before +2.1.0. You may need to re-run configure, setting the +variables PYTHON_CPPFLAGS, PYTHON_LDFLAGS, PYTHON_SITE_PKG, +PYTHON_EXTRA_LIBS and PYTHON_EXTRA_LDFLAGS by hand. +Moreover, to disable this check, set PYTHON_NOVERSIONCHECK +to something else than an empty string. + +See \`config.log' for more details" "$LINENO" 5; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: skip at user request" >&5 +$as_echo "skip at user request" >&6; } + fi + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + fi + + # + # if the macro parameter ``version'' is set, honour it + # + if test -n ">= '2.7'"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a version of Python >= '2.7'" >&5 +$as_echo_n "checking for a version of Python >= '2.7'... " >&6; } + ac_supports_python_ver=`$PYTHON -c "import sys, string; \ + ver = string.split(sys.version)[0]; \ + print ver >= '2.7'"` + if test "$ac_supports_python_ver" = "True"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + as_fn_error $? "this package requires Python >= '2.7'. +If you have it installed, but it isn't the default Python +interpreter in your system path, please pass the PYTHON_VERSION +variable to configure. See \`\`configure --help'' for reference. +" "$LINENO" 5 + PYTHON_VERSION="" + fi + fi + + # + # Check if you have distutils, else fail + # + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for the distutils Python package" >&5 +$as_echo_n "checking for the distutils Python package... " >&6; } + ac_distutils_result=`$PYTHON -c "import distutils" 2>&1` + if test -z "$ac_distutils_result"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + as_fn_error $? "cannot import Python module \"distutils\". +Please check your Python installation. The error was: +$ac_distutils_result" "$LINENO" 5 + PYTHON_VERSION="" + fi + + # + # Check for Python include path + # + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python include path" >&5 +$as_echo_n "checking for Python include path... " >&6; } + if test -z "$PYTHON_CPPFLAGS"; then + python_path=`$PYTHON -c "import distutils.sysconfig; \ + print distutils.sysconfig.get_python_inc();"` + if test -n "${python_path}"; then + python_path="-I$python_path" + fi + PYTHON_CPPFLAGS=$python_path + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON_CPPFLAGS" >&5 +$as_echo "$PYTHON_CPPFLAGS" >&6; } + + + # + # Check for Python library path + # + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python library path" >&5 +$as_echo_n "checking for Python library path... " >&6; } + if test -z "$PYTHON_LDFLAGS"; then + # (makes two attempts to ensure we've got a version number + # from the interpreter) + py_version=`$PYTHON -c "from distutils.sysconfig import *; \ + from string import join; \ + print join(get_config_vars('VERSION'))"` + if test "$py_version" == "None"; then + if test -n "$PYTHON_VERSION"; then + py_version=$PYTHON_VERSION + else + py_version=`$PYTHON -c "import sys; \ + print sys.version[:3]"` + fi + fi + + PYTHON_LDFLAGS=`$PYTHON -c "from distutils.sysconfig import *; \ + from string import join; \ + print '-L' + get_python_lib(0,1), \ + '-lpython';"`$py_version + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON_LDFLAGS" >&5 +$as_echo "$PYTHON_LDFLAGS" >&6; } + + + # + # Check for site packages + # + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python site-packages path" >&5 +$as_echo_n "checking for Python site-packages path... " >&6; } + if test -z "$PYTHON_SITE_PKG"; then + PYTHON_SITE_PKG=`$PYTHON -c "import distutils.sysconfig; \ + print distutils.sysconfig.get_python_lib(0,0);"` + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON_SITE_PKG" >&5 +$as_echo "$PYTHON_SITE_PKG" >&6; } + + + # + # libraries which must be linked in when embedding + # + { $as_echo "$as_me:${as_lineno-$LINENO}: checking python extra libraries" >&5 +$as_echo_n "checking python extra libraries... " >&6; } + if test -z "$PYTHON_EXTRA_LIBS"; then + PYTHON_EXTRA_LIBS=`$PYTHON -c "import distutils.sysconfig; \ + conf = distutils.sysconfig.get_config_var; \ + print conf('LOCALMODLIBS'), conf('LIBS')"` + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON_EXTRA_LIBS" >&5 +$as_echo "$PYTHON_EXTRA_LIBS" >&6; } + + + # + # linking flags needed when embedding + # + { $as_echo "$as_me:${as_lineno-$LINENO}: checking python extra linking flags" >&5 +$as_echo_n "checking python extra linking flags... " >&6; } + if test -z "$PYTHON_EXTRA_LDFLAGS"; then + PYTHON_EXTRA_LDFLAGS=`$PYTHON -c "import distutils.sysconfig; \ + conf = distutils.sysconfig.get_config_var; \ + print conf('LINKFORSHARED')"` + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON_EXTRA_LDFLAGS" >&5 +$as_echo "$PYTHON_EXTRA_LDFLAGS" >&6; } + + + # + # final check to see if everything compiles alright + # + { $as_echo "$as_me:${as_lineno-$LINENO}: checking consistency of all components of python development environment" >&5 +$as_echo_n "checking consistency of all components of python development environment... " >&6; } + ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + # save current global flags + LIBS="$ac_save_LIBS $PYTHON_LDFLAGS" + CPPFLAGS="$ac_save_CPPFLAGS $PYTHON_CPPFLAGS" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + + #include + +int +main () +{ + + Py_Initialize(); + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + pythonexists=yes +else + pythonexists=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $pythonexists" >&5 +$as_echo "$pythonexists" >&6; } + + if test ! "$pythonexists" = "yes"; then + as_fn_error $? " + Could not link test program to Python. Maybe the main Python library has been + installed in some non-standard library path. If so, pass it to configure, + via the LDFLAGS environment variable. + Example: ./configure LDFLAGS=\"-L/usr/non-standard-path/python/lib\" + ============================================================================ + ERROR! + You probably have to install the development version of the Python package + for your distribution. The exact name of this package varies among them. + ============================================================================ + " "$LINENO" 5 + PYTHON_VERSION="" + fi + ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + # turn back to default flags + CPPFLAGS="$ac_save_CPPFLAGS" + LIBS="$ac_save_LIBS" + + # + # all done! + # + +fi + +# Check whether --enable-special was given. +if test "${enable_special+set}" = set; then : + enableval=$enable_special; +else + enable_special=no +fi + + if test "x$enable_special" != xno; then + HAVE_SPECIAL_TRUE= + HAVE_SPECIAL_FALSE='#' +else + HAVE_SPECIAL_TRUE='#' + HAVE_SPECIAL_FALSE= +fi + + +# --enable-bin enables script and bin "extensions". +# Check whether --enable-bin was given. +if test "${enable_bin+set}" = set; then : + enableval=$enable_bin; +else + enable_bin=yes +fi + + if test "x$enable_bin" != xno; then + HAVE_BIN_TRUE= + HAVE_BIN_FALSE='#' +else + HAVE_BIN_TRUE='#' + HAVE_BIN_FALSE= +fi + + if test "x$enable_bin" != xno; then + HAVE_SCRIPT_TRUE= + HAVE_SCRIPT_FALSE='#' +else + HAVE_SCRIPT_TRUE='#' + HAVE_SCRIPT_FALSE= +fi + + +# --enable-grm enables dependencies of OpenGrm: far, mpdt, and pdt. +# Check whether --enable-grm was given. +if test "${enable_grm+set}" = set; then : + enableval=$enable_grm; +else + enable_grm=no +fi + + if test "x$enable_grm" != xno; then + HAVE_GRM_TRUE= + HAVE_GRM_FALSE='#' +else + HAVE_GRM_TRUE='#' + HAVE_GRM_FALSE= +fi + + + +# Check whether --with-libfstdir was given. +if test "${with_libfstdir+set}" = set; then : + withval=$with_libfstdir; +else + with_libfstdir=${libdir}/fst +fi + + +libfstdir=$with_libfstdir + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 +$as_echo_n "checking for dlopen in -ldl... " >&6; } +if ${ac_cv_lib_dl_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldl $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + ac_cv_lib_dl_dlopen=yes +else + ac_cv_lib_dl_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +$as_echo "$ac_cv_lib_dl_dlopen" >&6; } +if test "x$ac_cv_lib_dl_dlopen" = xyes; then : + DL_LIBS=-ldl +fi + + + +cat >confcache <<\_ACEOF +# This file is a shell script that caches the results of configure +# tests run on this system so they can be shared between configure +# scripts and configure runs, see configure's option --config-cache. +# It is not useful on other systems. If it contains results you don't +# want to keep, you may remove or edit it. +# +# config.status only pays attention to the cache file if you give it +# the --recheck option to rerun configure. +# +# `ac_cv_env_foo' variables (set or unset) will be overridden when +# loading this file, other *unset* `ac_cv_foo' will be assigned the +# following values. + +_ACEOF + +# The following way of writing the cache mishandles newlines in values, +# but we know of no workaround that is simple, portable, and efficient. +# So, we kill variables containing newlines. +# Ultrix sh set writes to stderr and can't be redirected directly, +# and sets the high bit in the cache file unless we assign to the vars. +( + for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do + eval ac_val=\$$ac_var + case $ac_val in #( + *${as_nl}*) + case $ac_var in #( + *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 +$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; + esac + case $ac_var in #( + _ | IFS | as_nl) ;; #( + BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( + *) { eval $ac_var=; unset $ac_var;} ;; + esac ;; + esac + done + + (set) 2>&1 | + case $as_nl`(ac_space=' '; set) 2>&1` in #( + *${as_nl}ac_space=\ *) + # `set' does not quote correctly, so add quotes: double-quote + # substitution turns \\\\ into \\, and sed turns \\ into \. + sed -n \ + "s/'/'\\\\''/g; + s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" + ;; #( + *) + # `set' quotes correctly as required by POSIX, so do not add quotes. + sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" + ;; + esac | + sort +) | + sed ' + /^ac_cv_env_/b end + t clear + :clear + s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ + t end + s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ + :end' >>confcache +if diff "$cache_file" confcache >/dev/null 2>&1; then :; else + if test -w "$cache_file"; then + if test "x$cache_file" != "x/dev/null"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 +$as_echo "$as_me: updating cache $cache_file" >&6;} + if test ! -f "$cache_file" || test -h "$cache_file"; then + cat confcache >"$cache_file" + else + case $cache_file in #( + */* | ?:*) + mv -f confcache "$cache_file"$$ && + mv -f "$cache_file"$$ "$cache_file" ;; #( + *) + mv -f confcache "$cache_file" ;; + esac + fi + fi + else + { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 +$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;} + fi +fi +rm -f confcache + +test "x$prefix" = xNONE && prefix=$ac_default_prefix +# Let make expand exec_prefix. +test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' + +DEFS=-DHAVE_CONFIG_H + +ac_libobjs= +ac_ltlibobjs= +U= +for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue + # 1. Remove the extension, and $U if already installed. + ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' + ac_i=`$as_echo "$ac_i" | sed "$ac_script"` + # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR + # will be set to the directory where LIBOBJS objects are built. + as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" + as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo' +done +LIBOBJS=$ac_libobjs + +LTLIBOBJS=$ac_ltlibobjs + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5 +$as_echo_n "checking that generated files are newer than configure... " >&6; } + if test -n "$am_sleep_pid"; then + # Hide warnings about reused PIDs. + wait $am_sleep_pid 2>/dev/null + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: result: done" >&5 +$as_echo "done" >&6; } + if test -n "$EXEEXT"; then + am__EXEEXT_TRUE= + am__EXEEXT_FALSE='#' +else + am__EXEEXT_TRUE='#' + am__EXEEXT_FALSE= +fi + +if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then + as_fn_error $? "conditional \"AMDEP\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then + as_fn_error $? "conditional \"am__fastdepCC\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${am__fastdepCXX_TRUE}" && test -z "${am__fastdepCXX_FALSE}"; then + as_fn_error $? "conditional \"am__fastdepCXX\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${HAVE_COMPACT_TRUE}" && test -z "${HAVE_COMPACT_FALSE}"; then + as_fn_error $? "conditional \"HAVE_COMPACT\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${HAVE_COMPRESS_TRUE}" && test -z "${HAVE_COMPRESS_FALSE}"; then + as_fn_error $? "conditional \"HAVE_COMPRESS\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${HAVE_CONST_TRUE}" && test -z "${HAVE_CONST_FALSE}"; then + as_fn_error $? "conditional \"HAVE_CONST\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${HAVE_FAR_TRUE}" && test -z "${HAVE_FAR_FALSE}"; then + as_fn_error $? "conditional \"HAVE_FAR\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${HAVE_LINEAR_TRUE}" && test -z "${HAVE_LINEAR_FALSE}"; then + as_fn_error $? "conditional \"HAVE_LINEAR\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${HAVE_LOOKAHEAD_TRUE}" && test -z "${HAVE_LOOKAHEAD_FALSE}"; then + as_fn_error $? "conditional \"HAVE_LOOKAHEAD\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${HAVE_MPDT_TRUE}" && test -z "${HAVE_MPDT_FALSE}"; then + as_fn_error $? "conditional \"HAVE_MPDT\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${HAVE_NGRAM_TRUE}" && test -z "${HAVE_NGRAM_FALSE}"; then + as_fn_error $? "conditional \"HAVE_NGRAM\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${HAVE_PDT_TRUE}" && test -z "${HAVE_PDT_FALSE}"; then + as_fn_error $? "conditional \"HAVE_PDT\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${HAVE_PYTHON_TRUE}" && test -z "${HAVE_PYTHON_FALSE}"; then + as_fn_error $? "conditional \"HAVE_PYTHON\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${HAVE_SPECIAL_TRUE}" && test -z "${HAVE_SPECIAL_FALSE}"; then + as_fn_error $? "conditional \"HAVE_SPECIAL\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${HAVE_BIN_TRUE}" && test -z "${HAVE_BIN_FALSE}"; then + as_fn_error $? "conditional \"HAVE_BIN\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${HAVE_SCRIPT_TRUE}" && test -z "${HAVE_SCRIPT_FALSE}"; then + as_fn_error $? "conditional \"HAVE_SCRIPT\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${HAVE_GRM_TRUE}" && test -z "${HAVE_GRM_FALSE}"; then + as_fn_error $? "conditional \"HAVE_GRM\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi + +: "${CONFIG_STATUS=./config.status}" +ac_write_fail=0 +ac_clean_files_save=$ac_clean_files +ac_clean_files="$ac_clean_files $CONFIG_STATUS" +{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 +$as_echo "$as_me: creating $CONFIG_STATUS" >&6;} +as_write_fail=0 +cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 +#! $SHELL +# Generated by $as_me. +# Run this file to recreate the current configuration. +# Compiler output produced by configure, useful for debugging +# configure, is in config.log if it exists. + +debug=false +ac_cs_recheck=false +ac_cs_silent=false + +SHELL=\${CONFIG_SHELL-$SHELL} +export SHELL +_ASEOF +cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 +## -------------------- ## +## M4sh Initialization. ## +## -------------------- ## + +# Be more Bourne compatible +DUALCASE=1; export DUALCASE # for MKS sh +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' + setopt NO_GLOB_SUBST +else + case `(set -o) 2>/dev/null` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi + + +as_nl=' +' +export as_nl +# Printing a long string crashes Solaris 7 /usr/bin/printf. +as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo +# Prefer a ksh shell builtin over an external printf program on Solaris, +# but without wasting forks for bash or zsh. +if test -z "$BASH_VERSION$ZSH_VERSION" \ + && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='print -r --' + as_echo_n='print -rn --' +elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='printf %s\n' + as_echo_n='printf %s' +else + if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then + as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' + as_echo_n='/usr/ucb/echo -n' + else + as_echo_body='eval expr "X$1" : "X\\(.*\\)"' + as_echo_n_body='eval + arg=$1; + case $arg in #( + *"$as_nl"*) + expr "X$arg" : "X\\(.*\\)$as_nl"; + arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; + esac; + expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" + ' + export as_echo_n_body + as_echo_n='sh -c $as_echo_n_body as_echo' + fi + export as_echo_body + as_echo='sh -c $as_echo_body as_echo' +fi + +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || + PATH_SEPARATOR=';' + } +fi + + +# IFS +# We need space, tab and new line, in precisely that order. Quoting is +# there to prevent editors from complaining about space-tab. +# (If _AS_PATH_WALK were called with IFS unset, it would disable word +# splitting by setting IFS to empty value.) +IFS=" "" $as_nl" + +# Find who we are. Look in the path if we contain no directory separator. +as_myself= +case $0 in #(( + *[\\/]* ) as_myself=$0 ;; + *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + done +IFS=$as_save_IFS + + ;; +esac +# We did not find ourselves, most probably we were run as `sh COMMAND' +# in which case we are not to be found in the path. +if test "x$as_myself" = x; then + as_myself=$0 +fi +if test ! -f "$as_myself"; then + $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + exit 1 +fi + +# Unset variables that we do not need and which cause bugs (e.g. in +# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" +# suppresses any "Segmentation fault" message there. '((' could +# trigger a bug in pdksh 5.2.14. +for as_var in BASH_ENV ENV MAIL MAILPATH +do eval test x\${$as_var+set} = xset \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# CDPATH. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + + +# as_fn_error STATUS ERROR [LINENO LOG_FD] +# ---------------------------------------- +# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are +# provided, also output the error to LOG_FD, referencing LINENO. Then exit the +# script with STATUS, using 1 if that was 0. +as_fn_error () +{ + as_status=$1; test $as_status -eq 0 && as_status=1 + if test "$4"; then + as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + fi + $as_echo "$as_me: error: $2" >&2 + as_fn_exit $as_status +} # as_fn_error + + +# as_fn_set_status STATUS +# ----------------------- +# Set $? to STATUS, without forking. +as_fn_set_status () +{ + return $1 +} # as_fn_set_status + +# as_fn_exit STATUS +# ----------------- +# Exit the shell with STATUS, even in a "trap 0" or "set -e" context. +as_fn_exit () +{ + set +e + as_fn_set_status $1 + exit $1 +} # as_fn_exit + +# as_fn_unset VAR +# --------------- +# Portably unset VAR. +as_fn_unset () +{ + { eval $1=; unset $1;} +} +as_unset=as_fn_unset +# as_fn_append VAR VALUE +# ---------------------- +# Append the text in VALUE to the end of the definition contained in VAR. Take +# advantage of any shell optimizations that allow amortized linear growth over +# repeated appends, instead of the typical quadratic growth present in naive +# implementations. +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : + eval 'as_fn_append () + { + eval $1+=\$2 + }' +else + as_fn_append () + { + eval $1=\$$1\$2 + } +fi # as_fn_append + +# as_fn_arith ARG... +# ------------------ +# Perform arithmetic evaluation on the ARGs, and store the result in the +# global $as_val. Take advantage of shells that can avoid forks. The arguments +# must be portable across $(()) and expr. +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : + eval 'as_fn_arith () + { + as_val=$(( $* )) + }' +else + as_fn_arith () + { + as_val=`expr "$@" || test $? -eq 1` + } +fi # as_fn_arith + + +if expr a : '\(a\)' >/dev/null 2>&1 && + test "X`expr 00001 : '.*\(...\)'`" = X001; then + as_expr=expr +else + as_expr=false +fi + +if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi + +if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then + as_dirname=dirname +else + as_dirname=false +fi + +as_me=`$as_basename -- "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ + s//\1/ + q + } + /^X\/\(\/\/\)$/{ + s//\1/ + q + } + /^X\/\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits + +ECHO_C= ECHO_N= ECHO_T= +case `echo -n x` in #((((( +-n*) + case `echo 'xy\c'` in + *c*) ECHO_T=' ';; # ECHO_T is single tab character. + xy) ECHO_C='\c';; + *) echo `echo ksh88 bug on AIX 6.1` > /dev/null + ECHO_T=' ';; + esac;; +*) + ECHO_N='-n';; +esac + +rm -f conf$$ conf$$.exe conf$$.file +if test -d conf$$.dir; then + rm -f conf$$.dir/conf$$.file +else + rm -f conf$$.dir + mkdir conf$$.dir 2>/dev/null +fi +if (echo >conf$$.file) 2>/dev/null; then + if ln -s conf$$.file conf$$ 2>/dev/null; then + as_ln_s='ln -s' + # ... but there are two gotchas: + # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. + # In both cases, we have to default to `cp -pR'. + ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + as_ln_s='cp -pR' + elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln + else + as_ln_s='cp -pR' + fi +else + as_ln_s='cp -pR' +fi +rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file +rmdir conf$$.dir 2>/dev/null + + +# as_fn_mkdir_p +# ------------- +# Create "$as_dir" as a directory, including parents if necessary. +as_fn_mkdir_p () +{ + + case $as_dir in #( + -*) as_dir=./$as_dir;; + esac + test -d "$as_dir" || eval $as_mkdir_p || { + as_dirs= + while :; do + case $as_dir in #( + *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *) as_qdir=$as_dir;; + esac + as_dirs="'$as_qdir' $as_dirs" + as_dir=`$as_dirname -- "$as_dir" || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + test -d "$as_dir" && break + done + test -z "$as_dirs" || eval "mkdir $as_dirs" + } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" + + +} # as_fn_mkdir_p +if mkdir -p . 2>/dev/null; then + as_mkdir_p='mkdir -p "$as_dir"' +else + test -d ./-p && rmdir ./-p + as_mkdir_p=false +fi + + +# as_fn_executable_p FILE +# ----------------------- +# Test if FILE is an executable regular file. +as_fn_executable_p () +{ + test -f "$1" && test -x "$1" +} # as_fn_executable_p +as_test_x='test -x' +as_executable_p=as_fn_executable_p + +# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" + +# Sed expression to map a string onto a valid variable name. +as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" + + +exec 6>&1 +## ----------------------------------- ## +## Main body of $CONFIG_STATUS script. ## +## ----------------------------------- ## +_ASEOF +test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1 + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# Save the log message, to keep $0 and so on meaningful, and to +# report actual input values of CONFIG_FILES etc. instead of their +# values after options handling. +ac_log=" +This file was extended by OpenFst $as_me 1.6.7, which was +generated by GNU Autoconf 2.69. Invocation command line was + + CONFIG_FILES = $CONFIG_FILES + CONFIG_HEADERS = $CONFIG_HEADERS + CONFIG_LINKS = $CONFIG_LINKS + CONFIG_COMMANDS = $CONFIG_COMMANDS + $ $0 $@ + +on `(hostname || uname -n) 2>/dev/null | sed 1q` +" + +_ACEOF + +case $ac_config_files in *" +"*) set x $ac_config_files; shift; ac_config_files=$*;; +esac + +case $ac_config_headers in *" +"*) set x $ac_config_headers; shift; ac_config_headers=$*;; +esac + + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +# Files that config.status was made for. +config_files="$ac_config_files" +config_headers="$ac_config_headers" +config_commands="$ac_config_commands" + +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +ac_cs_usage="\ +\`$as_me' instantiates files and other configuration actions +from templates according to the current configuration. Unless the files +and actions are specified as TAGs, all are instantiated by default. + +Usage: $0 [OPTION]... [TAG]... + + -h, --help print this help, then exit + -V, --version print version number and configuration settings, then exit + --config print configuration, then exit + -q, --quiet, --silent + do not print progress messages + -d, --debug don't remove temporary files + --recheck update $as_me by reconfiguring in the same conditions + --file=FILE[:TEMPLATE] + instantiate the configuration file FILE + --header=FILE[:TEMPLATE] + instantiate the configuration header FILE + +Configuration files: +$config_files + +Configuration headers: +$config_headers + +Configuration commands: +$config_commands + +Report bugs to ." + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" +ac_cs_version="\\ +OpenFst config.status 1.6.7 +configured by $0, generated by GNU Autoconf 2.69, + with options \\"\$ac_cs_config\\" + +Copyright (C) 2012 Free Software Foundation, Inc. +This config.status script is free software; the Free Software Foundation +gives unlimited permission to copy, distribute and modify it." + +ac_pwd='$ac_pwd' +srcdir='$srcdir' +INSTALL='$INSTALL' +MKDIR_P='$MKDIR_P' +AWK='$AWK' +test -n "\$AWK" || AWK=awk +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# The default lists apply if the user does not specify any file. +ac_need_defaults=: +while test $# != 0 +do + case $1 in + --*=?*) + ac_option=`expr "X$1" : 'X\([^=]*\)='` + ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` + ac_shift=: + ;; + --*=) + ac_option=`expr "X$1" : 'X\([^=]*\)='` + ac_optarg= + ac_shift=: + ;; + *) + ac_option=$1 + ac_optarg=$2 + ac_shift=shift + ;; + esac + + case $ac_option in + # Handling of the options. + -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) + ac_cs_recheck=: ;; + --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) + $as_echo "$ac_cs_version"; exit ;; + --config | --confi | --conf | --con | --co | --c ) + $as_echo "$ac_cs_config"; exit ;; + --debug | --debu | --deb | --de | --d | -d ) + debug=: ;; + --file | --fil | --fi | --f ) + $ac_shift + case $ac_optarg in + *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; + '') as_fn_error $? "missing file argument" ;; + esac + as_fn_append CONFIG_FILES " '$ac_optarg'" + ac_need_defaults=false;; + --header | --heade | --head | --hea ) + $ac_shift + case $ac_optarg in + *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + as_fn_append CONFIG_HEADERS " '$ac_optarg'" + ac_need_defaults=false;; + --he | --h) + # Conflict between --help and --header + as_fn_error $? "ambiguous option: \`$1' +Try \`$0 --help' for more information.";; + --help | --hel | -h ) + $as_echo "$ac_cs_usage"; exit ;; + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil | --si | --s) + ac_cs_silent=: ;; + + # This is an error. + -*) as_fn_error $? "unrecognized option: \`$1' +Try \`$0 --help' for more information." ;; + + *) as_fn_append ac_config_targets " $1" + ac_need_defaults=false ;; + + esac + shift +done + +ac_configure_extra_args= + +if $ac_cs_silent; then + exec 6>/dev/null + ac_configure_extra_args="$ac_configure_extra_args --silent" +fi + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +if \$ac_cs_recheck; then + set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion + shift + \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 + CONFIG_SHELL='$SHELL' + export CONFIG_SHELL + exec "\$@" +fi + +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +exec 5>>config.log +{ + echo + sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX +## Running $as_me. ## +_ASBOX + $as_echo "$ac_log" +} >&5 + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +# +# INIT-COMMANDS +# +AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir" + + +# The HP-UX ksh and POSIX shell print the target directory to stdout +# if CDPATH is set. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + +sed_quote_subst='$sed_quote_subst' +double_quote_subst='$double_quote_subst' +delay_variable_subst='$delay_variable_subst' +enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`' +macro_version='`$ECHO "$macro_version" | $SED "$delay_single_quote_subst"`' +macro_revision='`$ECHO "$macro_revision" | $SED "$delay_single_quote_subst"`' +enable_shared='`$ECHO "$enable_shared" | $SED "$delay_single_quote_subst"`' +pic_mode='`$ECHO "$pic_mode" | $SED "$delay_single_quote_subst"`' +enable_fast_install='`$ECHO "$enable_fast_install" | $SED "$delay_single_quote_subst"`' +SHELL='`$ECHO "$SHELL" | $SED "$delay_single_quote_subst"`' +ECHO='`$ECHO "$ECHO" | $SED "$delay_single_quote_subst"`' +PATH_SEPARATOR='`$ECHO "$PATH_SEPARATOR" | $SED "$delay_single_quote_subst"`' +host_alias='`$ECHO "$host_alias" | $SED "$delay_single_quote_subst"`' +host='`$ECHO "$host" | $SED "$delay_single_quote_subst"`' +host_os='`$ECHO "$host_os" | $SED "$delay_single_quote_subst"`' +build_alias='`$ECHO "$build_alias" | $SED "$delay_single_quote_subst"`' +build='`$ECHO "$build" | $SED "$delay_single_quote_subst"`' +build_os='`$ECHO "$build_os" | $SED "$delay_single_quote_subst"`' +SED='`$ECHO "$SED" | $SED "$delay_single_quote_subst"`' +Xsed='`$ECHO "$Xsed" | $SED "$delay_single_quote_subst"`' +GREP='`$ECHO "$GREP" | $SED "$delay_single_quote_subst"`' +EGREP='`$ECHO "$EGREP" | $SED "$delay_single_quote_subst"`' +FGREP='`$ECHO "$FGREP" | $SED "$delay_single_quote_subst"`' +LD='`$ECHO "$LD" | $SED "$delay_single_quote_subst"`' +NM='`$ECHO "$NM" | $SED "$delay_single_quote_subst"`' +LN_S='`$ECHO "$LN_S" | $SED "$delay_single_quote_subst"`' +max_cmd_len='`$ECHO "$max_cmd_len" | $SED "$delay_single_quote_subst"`' +ac_objext='`$ECHO "$ac_objext" | $SED "$delay_single_quote_subst"`' +exeext='`$ECHO "$exeext" | $SED "$delay_single_quote_subst"`' +lt_unset='`$ECHO "$lt_unset" | $SED "$delay_single_quote_subst"`' +lt_SP2NL='`$ECHO "$lt_SP2NL" | $SED "$delay_single_quote_subst"`' +lt_NL2SP='`$ECHO "$lt_NL2SP" | $SED "$delay_single_quote_subst"`' +lt_cv_to_host_file_cmd='`$ECHO "$lt_cv_to_host_file_cmd" | $SED "$delay_single_quote_subst"`' +lt_cv_to_tool_file_cmd='`$ECHO "$lt_cv_to_tool_file_cmd" | $SED "$delay_single_quote_subst"`' +reload_flag='`$ECHO "$reload_flag" | $SED "$delay_single_quote_subst"`' +reload_cmds='`$ECHO "$reload_cmds" | $SED "$delay_single_quote_subst"`' +OBJDUMP='`$ECHO "$OBJDUMP" | $SED "$delay_single_quote_subst"`' +deplibs_check_method='`$ECHO "$deplibs_check_method" | $SED "$delay_single_quote_subst"`' +file_magic_cmd='`$ECHO "$file_magic_cmd" | $SED "$delay_single_quote_subst"`' +file_magic_glob='`$ECHO "$file_magic_glob" | $SED "$delay_single_quote_subst"`' +want_nocaseglob='`$ECHO "$want_nocaseglob" | $SED "$delay_single_quote_subst"`' +DLLTOOL='`$ECHO "$DLLTOOL" | $SED "$delay_single_quote_subst"`' +sharedlib_from_linklib_cmd='`$ECHO "$sharedlib_from_linklib_cmd" | $SED "$delay_single_quote_subst"`' +AR='`$ECHO "$AR" | $SED "$delay_single_quote_subst"`' +AR_FLAGS='`$ECHO "$AR_FLAGS" | $SED "$delay_single_quote_subst"`' +archiver_list_spec='`$ECHO "$archiver_list_spec" | $SED "$delay_single_quote_subst"`' +STRIP='`$ECHO "$STRIP" | $SED "$delay_single_quote_subst"`' +RANLIB='`$ECHO "$RANLIB" | $SED "$delay_single_quote_subst"`' +old_postinstall_cmds='`$ECHO "$old_postinstall_cmds" | $SED "$delay_single_quote_subst"`' +old_postuninstall_cmds='`$ECHO "$old_postuninstall_cmds" | $SED "$delay_single_quote_subst"`' +old_archive_cmds='`$ECHO "$old_archive_cmds" | $SED "$delay_single_quote_subst"`' +lock_old_archive_extraction='`$ECHO "$lock_old_archive_extraction" | $SED "$delay_single_quote_subst"`' +CC='`$ECHO "$CC" | $SED "$delay_single_quote_subst"`' +CFLAGS='`$ECHO "$CFLAGS" | $SED "$delay_single_quote_subst"`' +compiler='`$ECHO "$compiler" | $SED "$delay_single_quote_subst"`' +GCC='`$ECHO "$GCC" | $SED "$delay_single_quote_subst"`' +lt_cv_sys_global_symbol_pipe='`$ECHO "$lt_cv_sys_global_symbol_pipe" | $SED "$delay_single_quote_subst"`' +lt_cv_sys_global_symbol_to_cdecl='`$ECHO "$lt_cv_sys_global_symbol_to_cdecl" | $SED "$delay_single_quote_subst"`' +lt_cv_sys_global_symbol_to_c_name_address='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address" | $SED "$delay_single_quote_subst"`' +lt_cv_sys_global_symbol_to_c_name_address_lib_prefix='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address_lib_prefix" | $SED "$delay_single_quote_subst"`' +nm_file_list_spec='`$ECHO "$nm_file_list_spec" | $SED "$delay_single_quote_subst"`' +lt_sysroot='`$ECHO "$lt_sysroot" | $SED "$delay_single_quote_subst"`' +objdir='`$ECHO "$objdir" | $SED "$delay_single_quote_subst"`' +MAGIC_CMD='`$ECHO "$MAGIC_CMD" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_no_builtin_flag='`$ECHO "$lt_prog_compiler_no_builtin_flag" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_pic='`$ECHO "$lt_prog_compiler_pic" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_wl='`$ECHO "$lt_prog_compiler_wl" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_static='`$ECHO "$lt_prog_compiler_static" | $SED "$delay_single_quote_subst"`' +lt_cv_prog_compiler_c_o='`$ECHO "$lt_cv_prog_compiler_c_o" | $SED "$delay_single_quote_subst"`' +need_locks='`$ECHO "$need_locks" | $SED "$delay_single_quote_subst"`' +MANIFEST_TOOL='`$ECHO "$MANIFEST_TOOL" | $SED "$delay_single_quote_subst"`' +DSYMUTIL='`$ECHO "$DSYMUTIL" | $SED "$delay_single_quote_subst"`' +NMEDIT='`$ECHO "$NMEDIT" | $SED "$delay_single_quote_subst"`' +LIPO='`$ECHO "$LIPO" | $SED "$delay_single_quote_subst"`' +OTOOL='`$ECHO "$OTOOL" | $SED "$delay_single_quote_subst"`' +OTOOL64='`$ECHO "$OTOOL64" | $SED "$delay_single_quote_subst"`' +libext='`$ECHO "$libext" | $SED "$delay_single_quote_subst"`' +shrext_cmds='`$ECHO "$shrext_cmds" | $SED "$delay_single_quote_subst"`' +extract_expsyms_cmds='`$ECHO "$extract_expsyms_cmds" | $SED "$delay_single_quote_subst"`' +archive_cmds_need_lc='`$ECHO "$archive_cmds_need_lc" | $SED "$delay_single_quote_subst"`' +enable_shared_with_static_runtimes='`$ECHO "$enable_shared_with_static_runtimes" | $SED "$delay_single_quote_subst"`' +export_dynamic_flag_spec='`$ECHO "$export_dynamic_flag_spec" | $SED "$delay_single_quote_subst"`' +whole_archive_flag_spec='`$ECHO "$whole_archive_flag_spec" | $SED "$delay_single_quote_subst"`' +compiler_needs_object='`$ECHO "$compiler_needs_object" | $SED "$delay_single_quote_subst"`' +old_archive_from_new_cmds='`$ECHO "$old_archive_from_new_cmds" | $SED "$delay_single_quote_subst"`' +old_archive_from_expsyms_cmds='`$ECHO "$old_archive_from_expsyms_cmds" | $SED "$delay_single_quote_subst"`' +archive_cmds='`$ECHO "$archive_cmds" | $SED "$delay_single_quote_subst"`' +archive_expsym_cmds='`$ECHO "$archive_expsym_cmds" | $SED "$delay_single_quote_subst"`' +module_cmds='`$ECHO "$module_cmds" | $SED "$delay_single_quote_subst"`' +module_expsym_cmds='`$ECHO "$module_expsym_cmds" | $SED "$delay_single_quote_subst"`' +with_gnu_ld='`$ECHO "$with_gnu_ld" | $SED "$delay_single_quote_subst"`' +allow_undefined_flag='`$ECHO "$allow_undefined_flag" | $SED "$delay_single_quote_subst"`' +no_undefined_flag='`$ECHO "$no_undefined_flag" | $SED "$delay_single_quote_subst"`' +hardcode_libdir_flag_spec='`$ECHO "$hardcode_libdir_flag_spec" | $SED "$delay_single_quote_subst"`' +hardcode_libdir_separator='`$ECHO "$hardcode_libdir_separator" | $SED "$delay_single_quote_subst"`' +hardcode_direct='`$ECHO "$hardcode_direct" | $SED "$delay_single_quote_subst"`' +hardcode_direct_absolute='`$ECHO "$hardcode_direct_absolute" | $SED "$delay_single_quote_subst"`' +hardcode_minus_L='`$ECHO "$hardcode_minus_L" | $SED "$delay_single_quote_subst"`' +hardcode_shlibpath_var='`$ECHO "$hardcode_shlibpath_var" | $SED "$delay_single_quote_subst"`' +hardcode_automatic='`$ECHO "$hardcode_automatic" | $SED "$delay_single_quote_subst"`' +inherit_rpath='`$ECHO "$inherit_rpath" | $SED "$delay_single_quote_subst"`' +link_all_deplibs='`$ECHO "$link_all_deplibs" | $SED "$delay_single_quote_subst"`' +always_export_symbols='`$ECHO "$always_export_symbols" | $SED "$delay_single_quote_subst"`' +export_symbols_cmds='`$ECHO "$export_symbols_cmds" | $SED "$delay_single_quote_subst"`' +exclude_expsyms='`$ECHO "$exclude_expsyms" | $SED "$delay_single_quote_subst"`' +include_expsyms='`$ECHO "$include_expsyms" | $SED "$delay_single_quote_subst"`' +prelink_cmds='`$ECHO "$prelink_cmds" | $SED "$delay_single_quote_subst"`' +postlink_cmds='`$ECHO "$postlink_cmds" | $SED "$delay_single_quote_subst"`' +file_list_spec='`$ECHO "$file_list_spec" | $SED "$delay_single_quote_subst"`' +variables_saved_for_relink='`$ECHO "$variables_saved_for_relink" | $SED "$delay_single_quote_subst"`' +need_lib_prefix='`$ECHO "$need_lib_prefix" | $SED "$delay_single_quote_subst"`' +need_version='`$ECHO "$need_version" | $SED "$delay_single_quote_subst"`' +version_type='`$ECHO "$version_type" | $SED "$delay_single_quote_subst"`' +runpath_var='`$ECHO "$runpath_var" | $SED "$delay_single_quote_subst"`' +shlibpath_var='`$ECHO "$shlibpath_var" | $SED "$delay_single_quote_subst"`' +shlibpath_overrides_runpath='`$ECHO "$shlibpath_overrides_runpath" | $SED "$delay_single_quote_subst"`' +libname_spec='`$ECHO "$libname_spec" | $SED "$delay_single_quote_subst"`' +library_names_spec='`$ECHO "$library_names_spec" | $SED "$delay_single_quote_subst"`' +soname_spec='`$ECHO "$soname_spec" | $SED "$delay_single_quote_subst"`' +install_override_mode='`$ECHO "$install_override_mode" | $SED "$delay_single_quote_subst"`' +postinstall_cmds='`$ECHO "$postinstall_cmds" | $SED "$delay_single_quote_subst"`' +postuninstall_cmds='`$ECHO "$postuninstall_cmds" | $SED "$delay_single_quote_subst"`' +finish_cmds='`$ECHO "$finish_cmds" | $SED "$delay_single_quote_subst"`' +finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`' +hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`' +sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`' +sys_lib_dlsearch_path_spec='`$ECHO "$sys_lib_dlsearch_path_spec" | $SED "$delay_single_quote_subst"`' +hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`' +enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`' +enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`' +enable_dlopen_self_static='`$ECHO "$enable_dlopen_self_static" | $SED "$delay_single_quote_subst"`' +old_striplib='`$ECHO "$old_striplib" | $SED "$delay_single_quote_subst"`' +striplib='`$ECHO "$striplib" | $SED "$delay_single_quote_subst"`' +compiler_lib_search_dirs='`$ECHO "$compiler_lib_search_dirs" | $SED "$delay_single_quote_subst"`' +predep_objects='`$ECHO "$predep_objects" | $SED "$delay_single_quote_subst"`' +postdep_objects='`$ECHO "$postdep_objects" | $SED "$delay_single_quote_subst"`' +predeps='`$ECHO "$predeps" | $SED "$delay_single_quote_subst"`' +postdeps='`$ECHO "$postdeps" | $SED "$delay_single_quote_subst"`' +compiler_lib_search_path='`$ECHO "$compiler_lib_search_path" | $SED "$delay_single_quote_subst"`' +LD_CXX='`$ECHO "$LD_CXX" | $SED "$delay_single_quote_subst"`' +reload_flag_CXX='`$ECHO "$reload_flag_CXX" | $SED "$delay_single_quote_subst"`' +reload_cmds_CXX='`$ECHO "$reload_cmds_CXX" | $SED "$delay_single_quote_subst"`' +old_archive_cmds_CXX='`$ECHO "$old_archive_cmds_CXX" | $SED "$delay_single_quote_subst"`' +compiler_CXX='`$ECHO "$compiler_CXX" | $SED "$delay_single_quote_subst"`' +GCC_CXX='`$ECHO "$GCC_CXX" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_no_builtin_flag_CXX='`$ECHO "$lt_prog_compiler_no_builtin_flag_CXX" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_pic_CXX='`$ECHO "$lt_prog_compiler_pic_CXX" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_wl_CXX='`$ECHO "$lt_prog_compiler_wl_CXX" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_static_CXX='`$ECHO "$lt_prog_compiler_static_CXX" | $SED "$delay_single_quote_subst"`' +lt_cv_prog_compiler_c_o_CXX='`$ECHO "$lt_cv_prog_compiler_c_o_CXX" | $SED "$delay_single_quote_subst"`' +archive_cmds_need_lc_CXX='`$ECHO "$archive_cmds_need_lc_CXX" | $SED "$delay_single_quote_subst"`' +enable_shared_with_static_runtimes_CXX='`$ECHO "$enable_shared_with_static_runtimes_CXX" | $SED "$delay_single_quote_subst"`' +export_dynamic_flag_spec_CXX='`$ECHO "$export_dynamic_flag_spec_CXX" | $SED "$delay_single_quote_subst"`' +whole_archive_flag_spec_CXX='`$ECHO "$whole_archive_flag_spec_CXX" | $SED "$delay_single_quote_subst"`' +compiler_needs_object_CXX='`$ECHO "$compiler_needs_object_CXX" | $SED "$delay_single_quote_subst"`' +old_archive_from_new_cmds_CXX='`$ECHO "$old_archive_from_new_cmds_CXX" | $SED "$delay_single_quote_subst"`' +old_archive_from_expsyms_cmds_CXX='`$ECHO "$old_archive_from_expsyms_cmds_CXX" | $SED "$delay_single_quote_subst"`' +archive_cmds_CXX='`$ECHO "$archive_cmds_CXX" | $SED "$delay_single_quote_subst"`' +archive_expsym_cmds_CXX='`$ECHO "$archive_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`' +module_cmds_CXX='`$ECHO "$module_cmds_CXX" | $SED "$delay_single_quote_subst"`' +module_expsym_cmds_CXX='`$ECHO "$module_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`' +with_gnu_ld_CXX='`$ECHO "$with_gnu_ld_CXX" | $SED "$delay_single_quote_subst"`' +allow_undefined_flag_CXX='`$ECHO "$allow_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`' +no_undefined_flag_CXX='`$ECHO "$no_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_libdir_flag_spec_CXX='`$ECHO "$hardcode_libdir_flag_spec_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_libdir_separator_CXX='`$ECHO "$hardcode_libdir_separator_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_direct_CXX='`$ECHO "$hardcode_direct_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_direct_absolute_CXX='`$ECHO "$hardcode_direct_absolute_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_minus_L_CXX='`$ECHO "$hardcode_minus_L_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_shlibpath_var_CXX='`$ECHO "$hardcode_shlibpath_var_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_automatic_CXX='`$ECHO "$hardcode_automatic_CXX" | $SED "$delay_single_quote_subst"`' +inherit_rpath_CXX='`$ECHO "$inherit_rpath_CXX" | $SED "$delay_single_quote_subst"`' +link_all_deplibs_CXX='`$ECHO "$link_all_deplibs_CXX" | $SED "$delay_single_quote_subst"`' +always_export_symbols_CXX='`$ECHO "$always_export_symbols_CXX" | $SED "$delay_single_quote_subst"`' +export_symbols_cmds_CXX='`$ECHO "$export_symbols_cmds_CXX" | $SED "$delay_single_quote_subst"`' +exclude_expsyms_CXX='`$ECHO "$exclude_expsyms_CXX" | $SED "$delay_single_quote_subst"`' +include_expsyms_CXX='`$ECHO "$include_expsyms_CXX" | $SED "$delay_single_quote_subst"`' +prelink_cmds_CXX='`$ECHO "$prelink_cmds_CXX" | $SED "$delay_single_quote_subst"`' +postlink_cmds_CXX='`$ECHO "$postlink_cmds_CXX" | $SED "$delay_single_quote_subst"`' +file_list_spec_CXX='`$ECHO "$file_list_spec_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_action_CXX='`$ECHO "$hardcode_action_CXX" | $SED "$delay_single_quote_subst"`' +compiler_lib_search_dirs_CXX='`$ECHO "$compiler_lib_search_dirs_CXX" | $SED "$delay_single_quote_subst"`' +predep_objects_CXX='`$ECHO "$predep_objects_CXX" | $SED "$delay_single_quote_subst"`' +postdep_objects_CXX='`$ECHO "$postdep_objects_CXX" | $SED "$delay_single_quote_subst"`' +predeps_CXX='`$ECHO "$predeps_CXX" | $SED "$delay_single_quote_subst"`' +postdeps_CXX='`$ECHO "$postdeps_CXX" | $SED "$delay_single_quote_subst"`' +compiler_lib_search_path_CXX='`$ECHO "$compiler_lib_search_path_CXX" | $SED "$delay_single_quote_subst"`' + +LTCC='$LTCC' +LTCFLAGS='$LTCFLAGS' +compiler='$compiler_DEFAULT' + +# A function that is used when there is no print builtin or printf. +func_fallback_echo () +{ + eval 'cat <<_LTECHO_EOF +\$1 +_LTECHO_EOF' +} + +# Quote evaled strings. +for var in SHELL \ +ECHO \ +PATH_SEPARATOR \ +SED \ +GREP \ +EGREP \ +FGREP \ +LD \ +NM \ +LN_S \ +lt_SP2NL \ +lt_NL2SP \ +reload_flag \ +OBJDUMP \ +deplibs_check_method \ +file_magic_cmd \ +file_magic_glob \ +want_nocaseglob \ +DLLTOOL \ +sharedlib_from_linklib_cmd \ +AR \ +AR_FLAGS \ +archiver_list_spec \ +STRIP \ +RANLIB \ +CC \ +CFLAGS \ +compiler \ +lt_cv_sys_global_symbol_pipe \ +lt_cv_sys_global_symbol_to_cdecl \ +lt_cv_sys_global_symbol_to_c_name_address \ +lt_cv_sys_global_symbol_to_c_name_address_lib_prefix \ +nm_file_list_spec \ +lt_prog_compiler_no_builtin_flag \ +lt_prog_compiler_pic \ +lt_prog_compiler_wl \ +lt_prog_compiler_static \ +lt_cv_prog_compiler_c_o \ +need_locks \ +MANIFEST_TOOL \ +DSYMUTIL \ +NMEDIT \ +LIPO \ +OTOOL \ +OTOOL64 \ +shrext_cmds \ +export_dynamic_flag_spec \ +whole_archive_flag_spec \ +compiler_needs_object \ +with_gnu_ld \ +allow_undefined_flag \ +no_undefined_flag \ +hardcode_libdir_flag_spec \ +hardcode_libdir_separator \ +exclude_expsyms \ +include_expsyms \ +file_list_spec \ +variables_saved_for_relink \ +libname_spec \ +library_names_spec \ +soname_spec \ +install_override_mode \ +finish_eval \ +old_striplib \ +striplib \ +compiler_lib_search_dirs \ +predep_objects \ +postdep_objects \ +predeps \ +postdeps \ +compiler_lib_search_path \ +LD_CXX \ +reload_flag_CXX \ +compiler_CXX \ +lt_prog_compiler_no_builtin_flag_CXX \ +lt_prog_compiler_pic_CXX \ +lt_prog_compiler_wl_CXX \ +lt_prog_compiler_static_CXX \ +lt_cv_prog_compiler_c_o_CXX \ +export_dynamic_flag_spec_CXX \ +whole_archive_flag_spec_CXX \ +compiler_needs_object_CXX \ +with_gnu_ld_CXX \ +allow_undefined_flag_CXX \ +no_undefined_flag_CXX \ +hardcode_libdir_flag_spec_CXX \ +hardcode_libdir_separator_CXX \ +exclude_expsyms_CXX \ +include_expsyms_CXX \ +file_list_spec_CXX \ +compiler_lib_search_dirs_CXX \ +predep_objects_CXX \ +postdep_objects_CXX \ +predeps_CXX \ +postdeps_CXX \ +compiler_lib_search_path_CXX; do + case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in + *[\\\\\\\`\\"\\\$]*) + eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" + ;; + *) + eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" + ;; + esac +done + +# Double-quote double-evaled strings. +for var in reload_cmds \ +old_postinstall_cmds \ +old_postuninstall_cmds \ +old_archive_cmds \ +extract_expsyms_cmds \ +old_archive_from_new_cmds \ +old_archive_from_expsyms_cmds \ +archive_cmds \ +archive_expsym_cmds \ +module_cmds \ +module_expsym_cmds \ +export_symbols_cmds \ +prelink_cmds \ +postlink_cmds \ +postinstall_cmds \ +postuninstall_cmds \ +finish_cmds \ +sys_lib_search_path_spec \ +sys_lib_dlsearch_path_spec \ +reload_cmds_CXX \ +old_archive_cmds_CXX \ +old_archive_from_new_cmds_CXX \ +old_archive_from_expsyms_cmds_CXX \ +archive_cmds_CXX \ +archive_expsym_cmds_CXX \ +module_cmds_CXX \ +module_expsym_cmds_CXX \ +export_symbols_cmds_CXX \ +prelink_cmds_CXX \ +postlink_cmds_CXX; do + case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in + *[\\\\\\\`\\"\\\$]*) + eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" + ;; + *) + eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" + ;; + esac +done + +ac_aux_dir='$ac_aux_dir' +xsi_shell='$xsi_shell' +lt_shell_append='$lt_shell_append' + +# See if we are running on zsh, and set the options which allow our +# commands through without removal of \ escapes INIT. +if test -n "\${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST +fi + + + PACKAGE='$PACKAGE' + VERSION='$VERSION' + TIMESTAMP='$TIMESTAMP' + RM='$RM' + ofile='$ofile' + + + + + + +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 + +# Handling of arguments. +for ac_config_target in $ac_config_targets +do + case $ac_config_target in + "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;; + "libtool") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool" ;; + "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;; + "src/include/fst/config.h") CONFIG_HEADERS="$CONFIG_HEADERS src/include/fst/config.h" ;; + "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;; + "src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;; + "src/include/Makefile") CONFIG_FILES="$CONFIG_FILES src/include/Makefile" ;; + "src/lib/Makefile") CONFIG_FILES="$CONFIG_FILES src/lib/Makefile" ;; + "src/bin/Makefile") CONFIG_FILES="$CONFIG_FILES src/bin/Makefile" ;; + "src/test/Makefile") CONFIG_FILES="$CONFIG_FILES src/test/Makefile" ;; + "src/extensions/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/Makefile" ;; + "src/extensions/compact/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/compact/Makefile" ;; + "src/extensions/compress/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/compress/Makefile" ;; + "src/extensions/const/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/const/Makefile" ;; + "src/extensions/far/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/far/Makefile" ;; + "src/extensions/linear/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/linear/Makefile" ;; + "src/extensions/lookahead/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/lookahead/Makefile" ;; + "src/extensions/mpdt/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/mpdt/Makefile" ;; + "src/extensions/ngram/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/ngram/Makefile" ;; + "src/extensions/pdt/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/pdt/Makefile" ;; + "src/extensions/python/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/python/Makefile" ;; + "src/extensions/special/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/special/Makefile" ;; + "src/script/Makefile") CONFIG_FILES="$CONFIG_FILES src/script/Makefile" ;; + + *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; + esac +done + + +# If the user did not use the arguments to specify the items to instantiate, +# then the envvar interface is used. Set only those that are not. +# We use the long form for the default assignment because of an extremely +# bizarre bug on SunOS 4.1.3. +if $ac_need_defaults; then + test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files + test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers + test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands +fi + +# Have a temporary directory for convenience. Make it in the build tree +# simply because there is no reason against having it here, and in addition, +# creating and moving files from /tmp can sometimes cause problems. +# Hook for its removal unless debugging. +# Note that there is a small window in which the directory will not be cleaned: +# after its creation but before its name has been assigned to `$tmp'. +$debug || +{ + tmp= ac_tmp= + trap 'exit_status=$? + : "${ac_tmp:=$tmp}" + { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status +' 0 + trap 'as_fn_exit 1' 1 2 13 15 +} +# Create a (secure) tmp directory for tmp files. + +{ + tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && + test -d "$tmp" +} || +{ + tmp=./conf$$-$RANDOM + (umask 077 && mkdir "$tmp") +} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 +ac_tmp=$tmp + +# Set up the scripts for CONFIG_FILES section. +# No need to generate them if there are no CONFIG_FILES. +# This happens for instance with `./config.status config.h'. +if test -n "$CONFIG_FILES"; then + + +ac_cr=`echo X | tr X '\015'` +# On cygwin, bash can eat \r inside `` if the user requested igncr. +# But we know of no other shell where ac_cr would be empty at this +# point, so we can use a bashism as a fallback. +if test "x$ac_cr" = x; then + eval ac_cr=\$\'\\r\' +fi +ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null` +if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then + ac_cs_awk_cr='\\r' +else + ac_cs_awk_cr=$ac_cr +fi + +echo 'BEGIN {' >"$ac_tmp/subs1.awk" && +_ACEOF + + +{ + echo "cat >conf$$subs.awk <<_ACEOF" && + echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' && + echo "_ACEOF" +} >conf$$subs.sh || + as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 +ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'` +ac_delim='%!_!# ' +for ac_last_try in false false false false false :; do + . ./conf$$subs.sh || + as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 + + ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` + if test $ac_delim_n = $ac_delim_num; then + break + elif $ac_last_try; then + as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 + else + ac_delim="$ac_delim!$ac_delim _$ac_delim!! " + fi +done +rm -f conf$$subs.sh + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK && +_ACEOF +sed -n ' +h +s/^/S["/; s/!.*/"]=/ +p +g +s/^[^!]*!// +:repl +t repl +s/'"$ac_delim"'$// +t delim +:nl +h +s/\(.\{148\}\)..*/\1/ +t more1 +s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/ +p +n +b repl +:more1 +s/["\\]/\\&/g; s/^/"/; s/$/"\\/ +p +g +s/.\{148\}// +t nl +:delim +h +s/\(.\{148\}\)..*/\1/ +t more2 +s/["\\]/\\&/g; s/^/"/; s/$/"/ +p +b +:more2 +s/["\\]/\\&/g; s/^/"/; s/$/"\\/ +p +g +s/.\{148\}// +t delim +' >$CONFIG_STATUS || ac_write_fail=1 +rm -f conf$$subs.awk +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +_ACAWK +cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && + for (key in S) S_is_set[key] = 1 + FS = "" + +} +{ + line = $ 0 + nfields = split(line, field, "@") + substed = 0 + len = length(field[1]) + for (i = 2; i < nfields; i++) { + key = field[i] + keylen = length(key) + if (S_is_set[key]) { + value = S[key] + line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) + len += length(value) + length(field[++i]) + substed = 1 + } else + len += 1 + keylen + } + + print line +} + +_ACAWK +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then + sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" +else + cat +fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \ + || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 +_ACEOF + +# VPATH may cause trouble with some makes, so we remove sole $(srcdir), +# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and +# trailing colons and then remove the whole line if VPATH becomes empty +# (actually we leave an empty line to preserve line numbers). +if test "x$srcdir" = x.; then + ac_vpsub='/^[ ]*VPATH[ ]*=[ ]*/{ +h +s/// +s/^/:/ +s/[ ]*$/:/ +s/:\$(srcdir):/:/g +s/:\${srcdir}:/:/g +s/:@srcdir@:/:/g +s/^:*// +s/:*$// +x +s/\(=[ ]*\).*/\1/ +G +s/\n// +s/^[^=]*=[ ]*$// +}' +fi + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +fi # test -n "$CONFIG_FILES" + +# Set up the scripts for CONFIG_HEADERS section. +# No need to generate them if there are no CONFIG_HEADERS. +# This happens for instance with `./config.status Makefile'. +if test -n "$CONFIG_HEADERS"; then +cat >"$ac_tmp/defines.awk" <<\_ACAWK || +BEGIN { +_ACEOF + +# Transform confdefs.h into an awk script `defines.awk', embedded as +# here-document in config.status, that substitutes the proper values into +# config.h.in to produce config.h. + +# Create a delimiter string that does not exist in confdefs.h, to ease +# handling of long lines. +ac_delim='%!_!# ' +for ac_last_try in false false :; do + ac_tt=`sed -n "/$ac_delim/p" confdefs.h` + if test -z "$ac_tt"; then + break + elif $ac_last_try; then + as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5 + else + ac_delim="$ac_delim!$ac_delim _$ac_delim!! " + fi +done + +# For the awk script, D is an array of macro values keyed by name, +# likewise P contains macro parameters if any. Preserve backslash +# newline sequences. + +ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]* +sed -n ' +s/.\{148\}/&'"$ac_delim"'/g +t rset +:rset +s/^[ ]*#[ ]*define[ ][ ]*/ / +t def +d +:def +s/\\$// +t bsnl +s/["\\]/\\&/g +s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ +D["\1"]=" \3"/p +s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2"/p +d +:bsnl +s/["\\]/\\&/g +s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ +D["\1"]=" \3\\\\\\n"\\/p +t cont +s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p +t cont +d +:cont +n +s/.\{148\}/&'"$ac_delim"'/g +t clear +:clear +s/\\$// +t bsnlc +s/["\\]/\\&/g; s/^/"/; s/$/"/p +d +:bsnlc +s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p +b cont +' >$CONFIG_STATUS || ac_write_fail=1 + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 + for (key in D) D_is_set[key] = 1 + FS = "" +} +/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ { + line = \$ 0 + split(line, arg, " ") + if (arg[1] == "#") { + defundef = arg[2] + mac1 = arg[3] + } else { + defundef = substr(arg[1], 2) + mac1 = arg[2] + } + split(mac1, mac2, "(") #) + macro = mac2[1] + prefix = substr(line, 1, index(line, defundef) - 1) + if (D_is_set[macro]) { + # Preserve the white space surrounding the "#". + print prefix "define", macro P[macro] D[macro] + next + } else { + # Replace #undef with comments. This is necessary, for example, + # in the case of _POSIX_SOURCE, which is predefined and required + # on some systems where configure will not decide to define it. + if (defundef == "undef") { + print "/*", prefix defundef, macro, "*/" + next + } + } +} +{ print } +_ACAWK +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 + as_fn_error $? "could not setup config headers machinery" "$LINENO" 5 +fi # test -n "$CONFIG_HEADERS" + + +eval set X " :F $CONFIG_FILES :H $CONFIG_HEADERS :C $CONFIG_COMMANDS" +shift +for ac_tag +do + case $ac_tag in + :[FHLC]) ac_mode=$ac_tag; continue;; + esac + case $ac_mode$ac_tag in + :[FHL]*:*);; + :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;; + :[FH]-) ac_tag=-:-;; + :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; + esac + ac_save_IFS=$IFS + IFS=: + set x $ac_tag + IFS=$ac_save_IFS + shift + ac_file=$1 + shift + + case $ac_mode in + :L) ac_source=$1;; + :[FH]) + ac_file_inputs= + for ac_f + do + case $ac_f in + -) ac_f="$ac_tmp/stdin";; + *) # Look for the file first in the build tree, then in the source tree + # (if the path is not absolute). The absolute path cannot be DOS-style, + # because $ac_f cannot contain `:'. + test -f "$ac_f" || + case $ac_f in + [\\/$]*) false;; + *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; + esac || + as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; + esac + case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac + as_fn_append ac_file_inputs " '$ac_f'" + done + + # Let's still pretend it is `configure' which instantiates (i.e., don't + # use $as_me), people would be surprised to read: + # /* config.h. Generated by config.status. */ + configure_input='Generated from '` + $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' + `' by configure.' + if test x"$ac_file" != x-; then + configure_input="$ac_file. $configure_input" + { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 +$as_echo "$as_me: creating $ac_file" >&6;} + fi + # Neutralize special characters interpreted by sed in replacement strings. + case $configure_input in #( + *\&* | *\|* | *\\* ) + ac_sed_conf_input=`$as_echo "$configure_input" | + sed 's/[\\\\&|]/\\\\&/g'`;; #( + *) ac_sed_conf_input=$configure_input;; + esac + + case $ac_tag in + *:-:* | *:-) cat >"$ac_tmp/stdin" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; + esac + ;; + esac + + ac_dir=`$as_dirname -- "$ac_file" || +$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$ac_file" : 'X\(//\)[^/]' \| \ + X"$ac_file" : 'X\(//\)$' \| \ + X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$ac_file" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + as_dir="$ac_dir"; as_fn_mkdir_p + ac_builddir=. + +case "$ac_dir" in +.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; +*) + ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` + # A ".." for each directory in $ac_dir_suffix. + ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` + case $ac_top_builddir_sub in + "") ac_top_builddir_sub=. ac_top_build_prefix= ;; + *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; + esac ;; +esac +ac_abs_top_builddir=$ac_pwd +ac_abs_builddir=$ac_pwd$ac_dir_suffix +# for backward compatibility: +ac_top_builddir=$ac_top_build_prefix + +case $srcdir in + .) # We are building in place. + ac_srcdir=. + ac_top_srcdir=$ac_top_builddir_sub + ac_abs_top_srcdir=$ac_pwd ;; + [\\/]* | ?:[\\/]* ) # Absolute name. + ac_srcdir=$srcdir$ac_dir_suffix; + ac_top_srcdir=$srcdir + ac_abs_top_srcdir=$srcdir ;; + *) # Relative name. + ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix + ac_top_srcdir=$ac_top_build_prefix$srcdir + ac_abs_top_srcdir=$ac_pwd/$srcdir ;; +esac +ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix + + + case $ac_mode in + :F) + # + # CONFIG_FILE + # + + case $INSTALL in + [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;; + *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;; + esac + ac_MKDIR_P=$MKDIR_P + case $MKDIR_P in + [\\/$]* | ?:[\\/]* ) ;; + */*) ac_MKDIR_P=$ac_top_build_prefix$MKDIR_P ;; + esac +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# If the template does not know about datarootdir, expand it. +# FIXME: This hack should be removed a few years after 2.60. +ac_datarootdir_hack=; ac_datarootdir_seen= +ac_sed_dataroot=' +/datarootdir/ { + p + q +} +/@datadir@/p +/@docdir@/p +/@infodir@/p +/@localedir@/p +/@mandir@/p' +case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in +*datarootdir*) ac_datarootdir_seen=yes;; +*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 +$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 + ac_datarootdir_hack=' + s&@datadir@&$datadir&g + s&@docdir@&$docdir&g + s&@infodir@&$infodir&g + s&@localedir@&$localedir&g + s&@mandir@&$mandir&g + s&\\\${datarootdir}&$datarootdir&g' ;; +esac +_ACEOF + +# Neutralize VPATH when `$srcdir' = `.'. +# Shell code in configure.ac might set extrasub. +# FIXME: do we really want to maintain this feature? +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +ac_sed_extra="$ac_vpsub +$extrasub +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +:t +/@[a-zA-Z_][a-zA-Z_0-9]*@/!b +s|@configure_input@|$ac_sed_conf_input|;t t +s&@top_builddir@&$ac_top_builddir_sub&;t t +s&@top_build_prefix@&$ac_top_build_prefix&;t t +s&@srcdir@&$ac_srcdir&;t t +s&@abs_srcdir@&$ac_abs_srcdir&;t t +s&@top_srcdir@&$ac_top_srcdir&;t t +s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t +s&@builddir@&$ac_builddir&;t t +s&@abs_builddir@&$ac_abs_builddir&;t t +s&@abs_top_builddir@&$ac_abs_top_builddir&;t t +s&@INSTALL@&$ac_INSTALL&;t t +s&@MKDIR_P@&$ac_MKDIR_P&;t t +$ac_datarootdir_hack +" +eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \ + >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + +test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && + { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && + { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ + "$ac_tmp/out"`; test -z "$ac_out"; } && + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' +which seems to be undefined. Please make sure it is defined" >&5 +$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' +which seems to be undefined. Please make sure it is defined" >&2;} + + rm -f "$ac_tmp/stdin" + case $ac_file in + -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";; + *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";; + esac \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + ;; + :H) + # + # CONFIG_HEADER + # + if test x"$ac_file" != x-; then + { + $as_echo "/* $configure_input */" \ + && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" + } >"$ac_tmp/config.h" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then + { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 +$as_echo "$as_me: $ac_file is unchanged" >&6;} + else + rm -f "$ac_file" + mv "$ac_tmp/config.h" "$ac_file" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + fi + else + $as_echo "/* $configure_input */" \ + && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \ + || as_fn_error $? "could not create -" "$LINENO" 5 + fi +# Compute "$ac_file"'s index in $config_headers. +_am_arg="$ac_file" +_am_stamp_count=1 +for _am_header in $config_headers :; do + case $_am_header in + $_am_arg | $_am_arg:* ) + break ;; + * ) + _am_stamp_count=`expr $_am_stamp_count + 1` ;; + esac +done +echo "timestamp for $_am_arg" >`$as_dirname -- "$_am_arg" || +$as_expr X"$_am_arg" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$_am_arg" : 'X\(//\)[^/]' \| \ + X"$_am_arg" : 'X\(//\)$' \| \ + X"$_am_arg" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$_am_arg" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'`/stamp-h$_am_stamp_count + ;; + + :C) { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5 +$as_echo "$as_me: executing $ac_file commands" >&6;} + ;; + esac + + + case $ac_file$ac_mode in + "depfiles":C) test x"$AMDEP_TRUE" != x"" || { + # Older Autoconf quotes --file arguments for eval, but not when files + # are listed without --file. Let's play safe and only enable the eval + # if we detect the quoting. + case $CONFIG_FILES in + *\'*) eval set x "$CONFIG_FILES" ;; + *) set x $CONFIG_FILES ;; + esac + shift + for mf + do + # Strip MF so we end up with the name of the file. + mf=`echo "$mf" | sed -e 's/:.*$//'` + # Check whether this is an Automake generated Makefile or not. + # We used to match only the files named 'Makefile.in', but + # some people rename them; so instead we look at the file content. + # Grep'ing the first line is not enough: some people post-process + # each Makefile.in and add a new line on top of each file to say so. + # Grep'ing the whole file is not good either: AIX grep has a line + # limit of 2048, but all sed's we know have understand at least 4000. + if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then + dirpart=`$as_dirname -- "$mf" || +$as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$mf" : 'X\(//\)[^/]' \| \ + X"$mf" : 'X\(//\)$' \| \ + X"$mf" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$mf" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + else + continue + fi + # Extract the definition of DEPDIR, am__include, and am__quote + # from the Makefile without running 'make'. + DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"` + test -z "$DEPDIR" && continue + am__include=`sed -n 's/^am__include = //p' < "$mf"` + test -z "$am__include" && continue + am__quote=`sed -n 's/^am__quote = //p' < "$mf"` + # Find all dependency output files, they are included files with + # $(DEPDIR) in their names. We invoke sed twice because it is the + # simplest approach to changing $(DEPDIR) to its actual value in the + # expansion. + for file in `sed -n " + s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \ + sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do + # Make sure the directory exists. + test -f "$dirpart/$file" && continue + fdir=`$as_dirname -- "$file" || +$as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$file" : 'X\(//\)[^/]' \| \ + X"$file" : 'X\(//\)$' \| \ + X"$file" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$file" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + as_dir=$dirpart/$fdir; as_fn_mkdir_p + # echo "creating $dirpart/$file" + echo '# dummy' > "$dirpart/$file" + done + done +} + ;; + "libtool":C) + + # See if we are running on zsh, and set the options which allow our + # commands through without removal of \ escapes. + if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST + fi + + cfgfile="${ofile}T" + trap "$RM \"$cfgfile\"; exit 1" 1 2 15 + $RM "$cfgfile" + + cat <<_LT_EOF >> "$cfgfile" +#! $SHELL + +# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services. +# Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION +# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: +# NOTE: Changes made to this file will be lost: look at ltmain.sh. +# +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, +# 2006, 2007, 2008, 2009, 2010, 2011 Free Software +# Foundation, Inc. +# Written by Gordon Matzigkeit, 1996 +# +# This file is part of GNU Libtool. +# +# GNU Libtool is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License as +# published by the Free Software Foundation; either version 2 of +# the License, or (at your option) any later version. +# +# As a special exception to the GNU General Public License, +# if you distribute this file as part of a program or library that +# is built using GNU Libtool, you may include this file under the +# same distribution terms that you use for the rest of that program. +# +# GNU Libtool is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Libtool; see the file COPYING. If not, a copy +# can be downloaded from http://www.gnu.org/licenses/gpl.html, or +# obtained by writing to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + + +# The names of the tagged configurations supported by this script. +available_tags="CXX " + +# ### BEGIN LIBTOOL CONFIG + +# Whether or not to build static libraries. +build_old_libs=$enable_static + +# Which release of libtool.m4 was used? +macro_version=$macro_version +macro_revision=$macro_revision + +# Whether or not to build shared libraries. +build_libtool_libs=$enable_shared + +# What type of objects to build. +pic_mode=$pic_mode + +# Whether or not to optimize for fast installation. +fast_install=$enable_fast_install + +# Shell to use when invoking shell scripts. +SHELL=$lt_SHELL + +# An echo program that protects backslashes. +ECHO=$lt_ECHO + +# The PATH separator for the build system. +PATH_SEPARATOR=$lt_PATH_SEPARATOR + +# The host system. +host_alias=$host_alias +host=$host +host_os=$host_os + +# The build system. +build_alias=$build_alias +build=$build +build_os=$build_os + +# A sed program that does not truncate output. +SED=$lt_SED + +# Sed that helps us avoid accidentally triggering echo(1) options like -n. +Xsed="\$SED -e 1s/^X//" + +# A grep program that handles long lines. +GREP=$lt_GREP + +# An ERE matcher. +EGREP=$lt_EGREP + +# A literal string matcher. +FGREP=$lt_FGREP + +# A BSD- or MS-compatible name lister. +NM=$lt_NM + +# Whether we need soft or hard links. +LN_S=$lt_LN_S + +# What is the maximum length of a command? +max_cmd_len=$max_cmd_len + +# Object file suffix (normally "o"). +objext=$ac_objext + +# Executable file suffix (normally ""). +exeext=$exeext + +# whether the shell understands "unset". +lt_unset=$lt_unset + +# turn spaces into newlines. +SP2NL=$lt_lt_SP2NL + +# turn newlines into spaces. +NL2SP=$lt_lt_NL2SP + +# convert \$build file names to \$host format. +to_host_file_cmd=$lt_cv_to_host_file_cmd + +# convert \$build files to toolchain format. +to_tool_file_cmd=$lt_cv_to_tool_file_cmd + +# An object symbol dumper. +OBJDUMP=$lt_OBJDUMP + +# Method to check whether dependent libraries are shared objects. +deplibs_check_method=$lt_deplibs_check_method + +# Command to use when deplibs_check_method = "file_magic". +file_magic_cmd=$lt_file_magic_cmd + +# How to find potential files when deplibs_check_method = "file_magic". +file_magic_glob=$lt_file_magic_glob + +# Find potential files using nocaseglob when deplibs_check_method = "file_magic". +want_nocaseglob=$lt_want_nocaseglob + +# DLL creation program. +DLLTOOL=$lt_DLLTOOL + +# Command to associate shared and link libraries. +sharedlib_from_linklib_cmd=$lt_sharedlib_from_linklib_cmd + +# The archiver. +AR=$lt_AR + +# Flags to create an archive. +AR_FLAGS=$lt_AR_FLAGS + +# How to feed a file listing to the archiver. +archiver_list_spec=$lt_archiver_list_spec + +# A symbol stripping program. +STRIP=$lt_STRIP + +# Commands used to install an old-style archive. +RANLIB=$lt_RANLIB +old_postinstall_cmds=$lt_old_postinstall_cmds +old_postuninstall_cmds=$lt_old_postuninstall_cmds + +# Whether to use a lock for old archive extraction. +lock_old_archive_extraction=$lock_old_archive_extraction + +# A C compiler. +LTCC=$lt_CC + +# LTCC compiler flags. +LTCFLAGS=$lt_CFLAGS + +# Take the output of nm and produce a listing of raw symbols and C names. +global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe + +# Transform the output of nm in a proper C declaration. +global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl + +# Transform the output of nm in a C name address pair. +global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address + +# Transform the output of nm in a C name address pair when lib prefix is needed. +global_symbol_to_c_name_address_lib_prefix=$lt_lt_cv_sys_global_symbol_to_c_name_address_lib_prefix + +# Specify filename containing input files for \$NM. +nm_file_list_spec=$lt_nm_file_list_spec + +# The root where to search for dependent libraries,and in which our libraries should be installed. +lt_sysroot=$lt_sysroot + +# The name of the directory that contains temporary libtool files. +objdir=$objdir + +# Used to examine libraries when file_magic_cmd begins with "file". +MAGIC_CMD=$MAGIC_CMD + +# Must we lock files when doing compilation? +need_locks=$lt_need_locks + +# Manifest tool. +MANIFEST_TOOL=$lt_MANIFEST_TOOL + +# Tool to manipulate archived DWARF debug symbol files on Mac OS X. +DSYMUTIL=$lt_DSYMUTIL + +# Tool to change global to local symbols on Mac OS X. +NMEDIT=$lt_NMEDIT + +# Tool to manipulate fat objects and archives on Mac OS X. +LIPO=$lt_LIPO + +# ldd/readelf like tool for Mach-O binaries on Mac OS X. +OTOOL=$lt_OTOOL + +# ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4. +OTOOL64=$lt_OTOOL64 + +# Old archive suffix (normally "a"). +libext=$libext + +# Shared library suffix (normally ".so"). +shrext_cmds=$lt_shrext_cmds + +# The commands to extract the exported symbol list from a shared archive. +extract_expsyms_cmds=$lt_extract_expsyms_cmds + +# Variables whose values should be saved in libtool wrapper scripts and +# restored at link time. +variables_saved_for_relink=$lt_variables_saved_for_relink + +# Do we need the "lib" prefix for modules? +need_lib_prefix=$need_lib_prefix + +# Do we need a version for libraries? +need_version=$need_version + +# Library versioning type. +version_type=$version_type + +# Shared library runtime path variable. +runpath_var=$runpath_var + +# Shared library path variable. +shlibpath_var=$shlibpath_var + +# Is shlibpath searched before the hard-coded library search path? +shlibpath_overrides_runpath=$shlibpath_overrides_runpath + +# Format of library name prefix. +libname_spec=$lt_libname_spec + +# List of archive names. First name is the real one, the rest are links. +# The last name is the one that the linker finds with -lNAME +library_names_spec=$lt_library_names_spec + +# The coded name of the library, if different from the real name. +soname_spec=$lt_soname_spec + +# Permission mode override for installation of shared libraries. +install_override_mode=$lt_install_override_mode + +# Command to use after installation of a shared archive. +postinstall_cmds=$lt_postinstall_cmds + +# Command to use after uninstallation of a shared archive. +postuninstall_cmds=$lt_postuninstall_cmds + +# Commands used to finish a libtool library installation in a directory. +finish_cmds=$lt_finish_cmds + +# As "finish_cmds", except a single script fragment to be evaled but +# not shown. +finish_eval=$lt_finish_eval + +# Whether we should hardcode library paths into libraries. +hardcode_into_libs=$hardcode_into_libs + +# Compile-time system search path for libraries. +sys_lib_search_path_spec=$lt_sys_lib_search_path_spec + +# Run-time system search path for libraries. +sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec + +# Whether dlopen is supported. +dlopen_support=$enable_dlopen + +# Whether dlopen of programs is supported. +dlopen_self=$enable_dlopen_self + +# Whether dlopen of statically linked programs is supported. +dlopen_self_static=$enable_dlopen_self_static + +# Commands to strip libraries. +old_striplib=$lt_old_striplib +striplib=$lt_striplib + + +# The linker used to build libraries. +LD=$lt_LD + +# How to create reloadable object files. +reload_flag=$lt_reload_flag +reload_cmds=$lt_reload_cmds + +# Commands used to build an old-style archive. +old_archive_cmds=$lt_old_archive_cmds + +# A language specific compiler. +CC=$lt_compiler + +# Is the compiler the GNU compiler? +with_gcc=$GCC + +# Compiler flag to turn off builtin functions. +no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag + +# Additional compiler flags for building library objects. +pic_flag=$lt_lt_prog_compiler_pic + +# How to pass a linker flag through the compiler. +wl=$lt_lt_prog_compiler_wl + +# Compiler flag to prevent dynamic linking. +link_static_flag=$lt_lt_prog_compiler_static + +# Does compiler simultaneously support -c and -o options? +compiler_c_o=$lt_lt_cv_prog_compiler_c_o + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=$archive_cmds_need_lc + +# Whether or not to disallow shared libs when runtime libs are static. +allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec=$lt_export_dynamic_flag_spec + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec=$lt_whole_archive_flag_spec + +# Whether the compiler copes with passing no objects directly. +compiler_needs_object=$lt_compiler_needs_object + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds=$lt_old_archive_from_new_cmds + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds + +# Commands used to build a shared archive. +archive_cmds=$lt_archive_cmds +archive_expsym_cmds=$lt_archive_expsym_cmds + +# Commands used to build a loadable module if different from building +# a shared archive. +module_cmds=$lt_module_cmds +module_expsym_cmds=$lt_module_expsym_cmds + +# Whether we are building with GNU ld or not. +with_gnu_ld=$lt_with_gnu_ld + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag=$lt_allow_undefined_flag + +# Flag that enforces no undefined symbols. +no_undefined_flag=$lt_no_undefined_flag + +# Flag to hardcode \$libdir into a binary during linking. +# This must work even if \$libdir does not exist +hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec + +# Whether we need a single "-rpath" flag with a separated argument. +hardcode_libdir_separator=$lt_hardcode_libdir_separator + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary. +hardcode_direct=$hardcode_direct + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary and the resulting library dependency is +# "absolute",i.e impossible to change by setting \${shlibpath_var} if the +# library is relocated. +hardcode_direct_absolute=$hardcode_direct_absolute + +# Set to "yes" if using the -LDIR flag during linking hardcodes DIR +# into the resulting binary. +hardcode_minus_L=$hardcode_minus_L + +# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR +# into the resulting binary. +hardcode_shlibpath_var=$hardcode_shlibpath_var + +# Set to "yes" if building a shared library automatically hardcodes DIR +# into the library and all subsequent libraries and executables linked +# against it. +hardcode_automatic=$hardcode_automatic + +# Set to yes if linker adds runtime paths of dependent libraries +# to runtime path list. +inherit_rpath=$inherit_rpath + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=$link_all_deplibs + +# Set to "yes" if exported symbols are required. +always_export_symbols=$always_export_symbols + +# The commands to list exported symbols. +export_symbols_cmds=$lt_export_symbols_cmds + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms=$lt_exclude_expsyms + +# Symbols that must always be exported. +include_expsyms=$lt_include_expsyms + +# Commands necessary for linking programs (against libraries) with templates. +prelink_cmds=$lt_prelink_cmds + +# Commands necessary for finishing linking programs. +postlink_cmds=$lt_postlink_cmds + +# Specify filename containing input files. +file_list_spec=$lt_file_list_spec + +# How to hardcode a shared library path into an executable. +hardcode_action=$hardcode_action + +# The directories searched by this compiler when creating a shared library. +compiler_lib_search_dirs=$lt_compiler_lib_search_dirs + +# Dependencies to place before and after the objects being linked to +# create a shared library. +predep_objects=$lt_predep_objects +postdep_objects=$lt_postdep_objects +predeps=$lt_predeps +postdeps=$lt_postdeps + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path=$lt_compiler_lib_search_path + +# ### END LIBTOOL CONFIG + +_LT_EOF + + case $host_os in + aix3*) + cat <<\_LT_EOF >> "$cfgfile" +# AIX sometimes has problems with the GCC collect2 program. For some +# reason, if we set the COLLECT_NAMES environment variable, the problems +# vanish in a puff of smoke. +if test "X${COLLECT_NAMES+set}" != Xset; then + COLLECT_NAMES= + export COLLECT_NAMES +fi +_LT_EOF + ;; + esac + + +ltmain="$ac_aux_dir/ltmain.sh" + + + # We use sed instead of cat because bash on DJGPP gets confused if + # if finds mixed CR/LF and LF-only lines. Since sed operates in + # text mode, it properly converts lines to CR/LF. This bash problem + # is reportedly fixed, but why not run on old versions too? + sed '$q' "$ltmain" >> "$cfgfile" \ + || (rm -f "$cfgfile"; exit 1) + + if test x"$xsi_shell" = xyes; then + sed -e '/^func_dirname ()$/,/^} # func_dirname /c\ +func_dirname ()\ +{\ +\ case ${1} in\ +\ */*) func_dirname_result="${1%/*}${2}" ;;\ +\ * ) func_dirname_result="${3}" ;;\ +\ esac\ +} # Extended-shell func_dirname implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_basename ()$/,/^} # func_basename /c\ +func_basename ()\ +{\ +\ func_basename_result="${1##*/}"\ +} # Extended-shell func_basename implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_dirname_and_basename ()$/,/^} # func_dirname_and_basename /c\ +func_dirname_and_basename ()\ +{\ +\ case ${1} in\ +\ */*) func_dirname_result="${1%/*}${2}" ;;\ +\ * ) func_dirname_result="${3}" ;;\ +\ esac\ +\ func_basename_result="${1##*/}"\ +} # Extended-shell func_dirname_and_basename implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_stripname ()$/,/^} # func_stripname /c\ +func_stripname ()\ +{\ +\ # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are\ +\ # positional parameters, so assign one to ordinary parameter first.\ +\ func_stripname_result=${3}\ +\ func_stripname_result=${func_stripname_result#"${1}"}\ +\ func_stripname_result=${func_stripname_result%"${2}"}\ +} # Extended-shell func_stripname implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_split_long_opt ()$/,/^} # func_split_long_opt /c\ +func_split_long_opt ()\ +{\ +\ func_split_long_opt_name=${1%%=*}\ +\ func_split_long_opt_arg=${1#*=}\ +} # Extended-shell func_split_long_opt implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_split_short_opt ()$/,/^} # func_split_short_opt /c\ +func_split_short_opt ()\ +{\ +\ func_split_short_opt_arg=${1#??}\ +\ func_split_short_opt_name=${1%"$func_split_short_opt_arg"}\ +} # Extended-shell func_split_short_opt implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_lo2o ()$/,/^} # func_lo2o /c\ +func_lo2o ()\ +{\ +\ case ${1} in\ +\ *.lo) func_lo2o_result=${1%.lo}.${objext} ;;\ +\ *) func_lo2o_result=${1} ;;\ +\ esac\ +} # Extended-shell func_lo2o implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_xform ()$/,/^} # func_xform /c\ +func_xform ()\ +{\ + func_xform_result=${1%.*}.lo\ +} # Extended-shell func_xform implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_arith ()$/,/^} # func_arith /c\ +func_arith ()\ +{\ + func_arith_result=$(( $* ))\ +} # Extended-shell func_arith implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_len ()$/,/^} # func_len /c\ +func_len ()\ +{\ + func_len_result=${#1}\ +} # Extended-shell func_len implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + +fi + +if test x"$lt_shell_append" = xyes; then + sed -e '/^func_append ()$/,/^} # func_append /c\ +func_append ()\ +{\ + eval "${1}+=\\${2}"\ +} # Extended-shell func_append implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_append_quoted ()$/,/^} # func_append_quoted /c\ +func_append_quoted ()\ +{\ +\ func_quote_for_eval "${2}"\ +\ eval "${1}+=\\\\ \\$func_quote_for_eval_result"\ +} # Extended-shell func_append_quoted implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + # Save a `func_append' function call where possible by direct use of '+=' + sed -e 's%func_append \([a-zA-Z_]\{1,\}\) "%\1+="%g' $cfgfile > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") + test 0 -eq $? || _lt_function_replace_fail=: +else + # Save a `func_append' function call even when '+=' is not available + sed -e 's%func_append \([a-zA-Z_]\{1,\}\) "%\1="$\1%g' $cfgfile > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") + test 0 -eq $? || _lt_function_replace_fail=: +fi + +if test x"$_lt_function_replace_fail" = x":"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Unable to substitute extended shell functions in $ofile" >&5 +$as_echo "$as_me: WARNING: Unable to substitute extended shell functions in $ofile" >&2;} +fi + + + mv -f "$cfgfile" "$ofile" || + (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile") + chmod +x "$ofile" + + + cat <<_LT_EOF >> "$ofile" + +# ### BEGIN LIBTOOL TAG CONFIG: CXX + +# The linker used to build libraries. +LD=$lt_LD_CXX + +# How to create reloadable object files. +reload_flag=$lt_reload_flag_CXX +reload_cmds=$lt_reload_cmds_CXX + +# Commands used to build an old-style archive. +old_archive_cmds=$lt_old_archive_cmds_CXX + +# A language specific compiler. +CC=$lt_compiler_CXX + +# Is the compiler the GNU compiler? +with_gcc=$GCC_CXX + +# Compiler flag to turn off builtin functions. +no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_CXX + +# Additional compiler flags for building library objects. +pic_flag=$lt_lt_prog_compiler_pic_CXX + +# How to pass a linker flag through the compiler. +wl=$lt_lt_prog_compiler_wl_CXX + +# Compiler flag to prevent dynamic linking. +link_static_flag=$lt_lt_prog_compiler_static_CXX + +# Does compiler simultaneously support -c and -o options? +compiler_c_o=$lt_lt_cv_prog_compiler_c_o_CXX + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=$archive_cmds_need_lc_CXX + +# Whether or not to disallow shared libs when runtime libs are static. +allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_CXX + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_CXX + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec=$lt_whole_archive_flag_spec_CXX + +# Whether the compiler copes with passing no objects directly. +compiler_needs_object=$lt_compiler_needs_object_CXX + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_CXX + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_CXX + +# Commands used to build a shared archive. +archive_cmds=$lt_archive_cmds_CXX +archive_expsym_cmds=$lt_archive_expsym_cmds_CXX + +# Commands used to build a loadable module if different from building +# a shared archive. +module_cmds=$lt_module_cmds_CXX +module_expsym_cmds=$lt_module_expsym_cmds_CXX + +# Whether we are building with GNU ld or not. +with_gnu_ld=$lt_with_gnu_ld_CXX + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag=$lt_allow_undefined_flag_CXX + +# Flag that enforces no undefined symbols. +no_undefined_flag=$lt_no_undefined_flag_CXX + +# Flag to hardcode \$libdir into a binary during linking. +# This must work even if \$libdir does not exist +hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_CXX + +# Whether we need a single "-rpath" flag with a separated argument. +hardcode_libdir_separator=$lt_hardcode_libdir_separator_CXX + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary. +hardcode_direct=$hardcode_direct_CXX + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary and the resulting library dependency is +# "absolute",i.e impossible to change by setting \${shlibpath_var} if the +# library is relocated. +hardcode_direct_absolute=$hardcode_direct_absolute_CXX + +# Set to "yes" if using the -LDIR flag during linking hardcodes DIR +# into the resulting binary. +hardcode_minus_L=$hardcode_minus_L_CXX + +# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR +# into the resulting binary. +hardcode_shlibpath_var=$hardcode_shlibpath_var_CXX + +# Set to "yes" if building a shared library automatically hardcodes DIR +# into the library and all subsequent libraries and executables linked +# against it. +hardcode_automatic=$hardcode_automatic_CXX + +# Set to yes if linker adds runtime paths of dependent libraries +# to runtime path list. +inherit_rpath=$inherit_rpath_CXX + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=$link_all_deplibs_CXX + +# Set to "yes" if exported symbols are required. +always_export_symbols=$always_export_symbols_CXX + +# The commands to list exported symbols. +export_symbols_cmds=$lt_export_symbols_cmds_CXX + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms=$lt_exclude_expsyms_CXX + +# Symbols that must always be exported. +include_expsyms=$lt_include_expsyms_CXX + +# Commands necessary for linking programs (against libraries) with templates. +prelink_cmds=$lt_prelink_cmds_CXX + +# Commands necessary for finishing linking programs. +postlink_cmds=$lt_postlink_cmds_CXX + +# Specify filename containing input files. +file_list_spec=$lt_file_list_spec_CXX + +# How to hardcode a shared library path into an executable. +hardcode_action=$hardcode_action_CXX + +# The directories searched by this compiler when creating a shared library. +compiler_lib_search_dirs=$lt_compiler_lib_search_dirs_CXX + +# Dependencies to place before and after the objects being linked to +# create a shared library. +predep_objects=$lt_predep_objects_CXX +postdep_objects=$lt_postdep_objects_CXX +predeps=$lt_predeps_CXX +postdeps=$lt_postdeps_CXX + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path=$lt_compiler_lib_search_path_CXX + +# ### END LIBTOOL TAG CONFIG: CXX +_LT_EOF + + ;; + + esac +done # for ac_tag + + +as_fn_exit 0 +_ACEOF +ac_clean_files=$ac_clean_files_save + +test $ac_write_fail = 0 || + as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5 + + +# configure is writing to config.log, and then calls config.status. +# config.status does its own redirection, appending to config.log. +# Unfortunately, on DOS this fails, as config.log is still kept open +# by configure, so config.status won't be able to write to it; its +# output is simply discarded. So we exec the FD to /dev/null, +# effectively closing config.log, so it can be properly (re)opened and +# appended to by config.status. When coming back to configure, we +# need to make the FD available again. +if test "$no_create" != yes; then + ac_cs_success=: + ac_config_status_args= + test "$silent" = yes && + ac_config_status_args="$ac_config_status_args --quiet" + exec 5>/dev/null + $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false + exec 5>>config.log + # Use ||, not &&, to avoid exiting from the if with $? = 1, which + # would make configure fail if this is the last instruction. + $ac_cs_success || as_fn_exit 1 +fi +if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 +$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} +fi + diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/configure.ac b/native_client/ctcdecode/third_party/openfst-1.6.7/configure.ac new file mode 100644 index 0000000000..bf2a16db47 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/configure.ac @@ -0,0 +1,147 @@ +AC_INIT([OpenFst], [1.6.7], [help@www.openfst.org]) +AM_INIT_AUTOMAKE([foreign nostdinc -Wall -Werror subdir-objects]) +AM_PROG_AR + +# OpenFst does not throw exceptions, so we do not generate exception handling +# code. However, users are free to re-enable exception handling. +# OpenFst assumes char is unsigned; -fsigned-char is likely unsafe. +CPPFLAGS="$CPPFLAGS -fno-exceptions -funsigned-char" +CXXFLAGS="$CXXFLAGS -std=c++11" + +AC_PROG_CXX +AC_DISABLE_STATIC +AC_PROG_LIBTOOL + +AC_CONFIG_HEADERS([config.h src/include/fst/config.h]) +AC_CONFIG_SRCDIR([src/lib/fst.cc]) +AC_CONFIG_FILES([ + Makefile + src/Makefile + src/include/Makefile + src/lib/Makefile + src/bin/Makefile + src/test/Makefile + src/extensions/Makefile + src/extensions/compact/Makefile + src/extensions/compress/Makefile + src/extensions/const/Makefile + src/extensions/far/Makefile + src/extensions/linear/Makefile + src/extensions/lookahead/Makefile + src/extensions/mpdt/Makefile + src/extensions/ngram/Makefile + src/extensions/pdt/Makefile + src/extensions/python/Makefile + src/extensions/special/Makefile + src/script/Makefile +]) +AC_CONFIG_MACRO_DIR([m4]) +AC_LANG([C++]) + +AC_ARG_ENABLE([compact-fsts], + [AS_HELP_STRING([--enable-compact-fsts], + [enable CompactFst extensions])], + [], + [enable_compact_fsts=no]) +AM_CONDITIONAL([HAVE_COMPACT], [test "x$enable_compact_fsts" != xno]) + +AC_ARG_ENABLE([compress], + [AS_HELP_STRING([--enable-compress], + [enable compression extension])], + [], + [enable_compress=no]) +AM_CONDITIONAL([HAVE_COMPRESS], [test "x$enable_compress" != xno]) + +AC_ARG_ENABLE([const-fsts], + [AS_HELP_STRING([--enable-const-fsts], + [enable ConstFst extensions])], + [], + [enable_const_fsts=no]) +AM_CONDITIONAL([HAVE_CONST], [test "x$enable_const_fsts" != xno]) + +AC_ARG_ENABLE([far], + [AS_HELP_STRING([--enable-far], [enable FAR extensions])], + [], + [enable_far=no]) +AM_CONDITIONAL([HAVE_FAR], [test "x$enable_far" != xno]) + +AC_ARG_ENABLE([linear-fsts], + [AS_HELP_STRING([--enable-linear-fsts], + [enable LinearTagger/ClassifierFst extensions])], + [], + [enable_linear_fsts=no]) +AM_CONDITIONAL([HAVE_LINEAR], [test "x$enable_linear_fsts" != xno]) + +AC_ARG_ENABLE([lookahead-fsts], + [AS_HELP_STRING([--enable-lookahead-fsts], + [enable LookAheadFst extensions])], + [], + [enable_lookahead_fsts=no]) +AM_CONDITIONAL([HAVE_LOOKAHEAD], [test "x$enable_lookahead_fsts" != xno]) + +AC_ARG_ENABLE([mpdt], + [AS_HELP_STRING([--enable-mpdt], + [enable MPDT extensions])], + [], + [enable_mpdt=no]) +AM_CONDITIONAL([HAVE_MPDT], [test "x$enable_mpdt" != xno]) + +AC_ARG_ENABLE([ngram-fsts], + [AS_HELP_STRING([--enable-ngram-fsts], + [enable NGramFst extension])], + [], + [enable_ngram_fsts=no]) +AM_CONDITIONAL([HAVE_NGRAM], [test "x$enable_ngram_fsts" != xno]) + +AC_ARG_ENABLE([pdt], + [AS_HELP_STRING([--enable-pdt], + [enable PDT extensions])], + [], + [enable_pdt=no]) +AM_CONDITIONAL([HAVE_PDT], [test "x$enable_pdt" != xno]) + +AC_ARG_ENABLE([python], + [AS_HELP_STRING([--enable-python], + [enable Python extensions])], + [], + [enable_python=no]) +AM_CONDITIONAL([HAVE_PYTHON], [test "x$enable_python" != xno]) +if test "x$enable_python" != xno; then + AM_PATH_PYTHON(2.7) + AC_PYTHON_DEVEL([>= '2.7']) +fi + +AC_ARG_ENABLE([special], + [AS_HELP_STRING([--enable-special], + [enable special-matcher extensions])], + [], + [enable_special=no]) +AM_CONDITIONAL([HAVE_SPECIAL], [test "x$enable_special" != xno]) + +# --enable-bin enables script and bin "extensions". +AC_ARG_ENABLE([bin], + [AS_HELP_STRING([--enable-bin], + [enable fst::script and command-line binaries])], + [], + [enable_bin=yes]) +AM_CONDITIONAL([HAVE_BIN], [test "x$enable_bin" != xno]) +AM_CONDITIONAL([HAVE_SCRIPT], [test "x$enable_bin" != xno]) + +# --enable-grm enables dependencies of OpenGrm: far, mpdt, and pdt. +AC_ARG_ENABLE([grm], + [AS_HELP_STRING([--enable-grm], + [enable all dependencies of OpenGrm])], + [], + [enable_grm=no]) +AM_CONDITIONAL([HAVE_GRM], [test "x$enable_grm" != xno]) + +AC_ARG_WITH([libfstdir], +[--with-libfstdir[=DIR] fst dynamic extensions [[LIBDIR/fst]]], +[], [with_libfstdir=[${libdir}/fst]]) + +AC_SUBST([libfstdir], $with_libfstdir) + +AC_CHECK_LIB([dl], dlopen, [DL_LIBS=-ldl]) +AC_SUBST([DL_LIBS]) + +AC_OUTPUT diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/depcomp b/native_client/ctcdecode/third_party/openfst-1.6.7/depcomp new file mode 100755 index 0000000000..4ebd5b3a2f --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/depcomp @@ -0,0 +1,791 @@ +#! /bin/sh +# depcomp - compile a program generating dependencies as side-effects + +scriptversion=2013-05-30.07; # UTC + +# Copyright (C) 1999-2013 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, or (at your option) +# any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +# Originally written by Alexandre Oliva . + +case $1 in + '') + echo "$0: No command. Try '$0 --help' for more information." 1>&2 + exit 1; + ;; + -h | --h*) + cat <<\EOF +Usage: depcomp [--help] [--version] PROGRAM [ARGS] + +Run PROGRAMS ARGS to compile a file, generating dependencies +as side-effects. + +Environment variables: + depmode Dependency tracking mode. + source Source file read by 'PROGRAMS ARGS'. + object Object file output by 'PROGRAMS ARGS'. + DEPDIR directory where to store dependencies. + depfile Dependency file to output. + tmpdepfile Temporary file to use when outputting dependencies. + libtool Whether libtool is used (yes/no). + +Report bugs to . +EOF + exit $? + ;; + -v | --v*) + echo "depcomp $scriptversion" + exit $? + ;; +esac + +# Get the directory component of the given path, and save it in the +# global variables '$dir'. Note that this directory component will +# be either empty or ending with a '/' character. This is deliberate. +set_dir_from () +{ + case $1 in + */*) dir=`echo "$1" | sed -e 's|/[^/]*$|/|'`;; + *) dir=;; + esac +} + +# Get the suffix-stripped basename of the given path, and save it the +# global variable '$base'. +set_base_from () +{ + base=`echo "$1" | sed -e 's|^.*/||' -e 's/\.[^.]*$//'` +} + +# If no dependency file was actually created by the compiler invocation, +# we still have to create a dummy depfile, to avoid errors with the +# Makefile "include basename.Plo" scheme. +make_dummy_depfile () +{ + echo "#dummy" > "$depfile" +} + +# Factor out some common post-processing of the generated depfile. +# Requires the auxiliary global variable '$tmpdepfile' to be set. +aix_post_process_depfile () +{ + # If the compiler actually managed to produce a dependency file, + # post-process it. + if test -f "$tmpdepfile"; then + # Each line is of the form 'foo.o: dependency.h'. + # Do two passes, one to just change these to + # $object: dependency.h + # and one to simply output + # dependency.h: + # which is needed to avoid the deleted-header problem. + { sed -e "s,^.*\.[$lower]*:,$object:," < "$tmpdepfile" + sed -e "s,^.*\.[$lower]*:[$tab ]*,," -e 's,$,:,' < "$tmpdepfile" + } > "$depfile" + rm -f "$tmpdepfile" + else + make_dummy_depfile + fi +} + +# A tabulation character. +tab=' ' +# A newline character. +nl=' +' +# Character ranges might be problematic outside the C locale. +# These definitions help. +upper=ABCDEFGHIJKLMNOPQRSTUVWXYZ +lower=abcdefghijklmnopqrstuvwxyz +digits=0123456789 +alpha=${upper}${lower} + +if test -z "$depmode" || test -z "$source" || test -z "$object"; then + echo "depcomp: Variables source, object and depmode must be set" 1>&2 + exit 1 +fi + +# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po. +depfile=${depfile-`echo "$object" | + sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`} +tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`} + +rm -f "$tmpdepfile" + +# Avoid interferences from the environment. +gccflag= dashmflag= + +# Some modes work just like other modes, but use different flags. We +# parameterize here, but still list the modes in the big case below, +# to make depend.m4 easier to write. Note that we *cannot* use a case +# here, because this file can only contain one case statement. +if test "$depmode" = hp; then + # HP compiler uses -M and no extra arg. + gccflag=-M + depmode=gcc +fi + +if test "$depmode" = dashXmstdout; then + # This is just like dashmstdout with a different argument. + dashmflag=-xM + depmode=dashmstdout +fi + +cygpath_u="cygpath -u -f -" +if test "$depmode" = msvcmsys; then + # This is just like msvisualcpp but w/o cygpath translation. + # Just convert the backslash-escaped backslashes to single forward + # slashes to satisfy depend.m4 + cygpath_u='sed s,\\\\,/,g' + depmode=msvisualcpp +fi + +if test "$depmode" = msvc7msys; then + # This is just like msvc7 but w/o cygpath translation. + # Just convert the backslash-escaped backslashes to single forward + # slashes to satisfy depend.m4 + cygpath_u='sed s,\\\\,/,g' + depmode=msvc7 +fi + +if test "$depmode" = xlc; then + # IBM C/C++ Compilers xlc/xlC can output gcc-like dependency information. + gccflag=-qmakedep=gcc,-MF + depmode=gcc +fi + +case "$depmode" in +gcc3) +## gcc 3 implements dependency tracking that does exactly what +## we want. Yay! Note: for some reason libtool 1.4 doesn't like +## it if -MD -MP comes after the -MF stuff. Hmm. +## Unfortunately, FreeBSD c89 acceptance of flags depends upon +## the command line argument order; so add the flags where they +## appear in depend2.am. Note that the slowdown incurred here +## affects only configure: in makefiles, %FASTDEP% shortcuts this. + for arg + do + case $arg in + -c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;; + *) set fnord "$@" "$arg" ;; + esac + shift # fnord + shift # $arg + done + "$@" + stat=$? + if test $stat -ne 0; then + rm -f "$tmpdepfile" + exit $stat + fi + mv "$tmpdepfile" "$depfile" + ;; + +gcc) +## Note that this doesn't just cater to obsosete pre-3.x GCC compilers. +## but also to in-use compilers like IMB xlc/xlC and the HP C compiler. +## (see the conditional assignment to $gccflag above). +## There are various ways to get dependency output from gcc. Here's +## why we pick this rather obscure method: +## - Don't want to use -MD because we'd like the dependencies to end +## up in a subdir. Having to rename by hand is ugly. +## (We might end up doing this anyway to support other compilers.) +## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like +## -MM, not -M (despite what the docs say). Also, it might not be +## supported by the other compilers which use the 'gcc' depmode. +## - Using -M directly means running the compiler twice (even worse +## than renaming). + if test -z "$gccflag"; then + gccflag=-MD, + fi + "$@" -Wp,"$gccflag$tmpdepfile" + stat=$? + if test $stat -ne 0; then + rm -f "$tmpdepfile" + exit $stat + fi + rm -f "$depfile" + echo "$object : \\" > "$depfile" + # The second -e expression handles DOS-style file names with drive + # letters. + sed -e 's/^[^:]*: / /' \ + -e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile" +## This next piece of magic avoids the "deleted header file" problem. +## The problem is that when a header file which appears in a .P file +## is deleted, the dependency causes make to die (because there is +## typically no way to rebuild the header). We avoid this by adding +## dummy dependencies for each header file. Too bad gcc doesn't do +## this for us directly. +## Some versions of gcc put a space before the ':'. On the theory +## that the space means something, we add a space to the output as +## well. hp depmode also adds that space, but also prefixes the VPATH +## to the object. Take care to not repeat it in the output. +## Some versions of the HPUX 10.20 sed can't process this invocation +## correctly. Breaking it into two sed invocations is a workaround. + tr ' ' "$nl" < "$tmpdepfile" \ + | sed -e 's/^\\$//' -e '/^$/d' -e "s|.*$object$||" -e '/:$/d' \ + | sed -e 's/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +hp) + # This case exists only to let depend.m4 do its work. It works by + # looking at the text of this script. This case will never be run, + # since it is checked for above. + exit 1 + ;; + +sgi) + if test "$libtool" = yes; then + "$@" "-Wp,-MDupdate,$tmpdepfile" + else + "$@" -MDupdate "$tmpdepfile" + fi + stat=$? + if test $stat -ne 0; then + rm -f "$tmpdepfile" + exit $stat + fi + rm -f "$depfile" + + if test -f "$tmpdepfile"; then # yes, the sourcefile depend on other files + echo "$object : \\" > "$depfile" + # Clip off the initial element (the dependent). Don't try to be + # clever and replace this with sed code, as IRIX sed won't handle + # lines with more than a fixed number of characters (4096 in + # IRIX 6.2 sed, 8192 in IRIX 6.5). We also remove comment lines; + # the IRIX cc adds comments like '#:fec' to the end of the + # dependency line. + tr ' ' "$nl" < "$tmpdepfile" \ + | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' \ + | tr "$nl" ' ' >> "$depfile" + echo >> "$depfile" + # The second pass generates a dummy entry for each header file. + tr ' ' "$nl" < "$tmpdepfile" \ + | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \ + >> "$depfile" + else + make_dummy_depfile + fi + rm -f "$tmpdepfile" + ;; + +xlc) + # This case exists only to let depend.m4 do its work. It works by + # looking at the text of this script. This case will never be run, + # since it is checked for above. + exit 1 + ;; + +aix) + # The C for AIX Compiler uses -M and outputs the dependencies + # in a .u file. In older versions, this file always lives in the + # current directory. Also, the AIX compiler puts '$object:' at the + # start of each line; $object doesn't have directory information. + # Version 6 uses the directory in both cases. + set_dir_from "$object" + set_base_from "$object" + if test "$libtool" = yes; then + tmpdepfile1=$dir$base.u + tmpdepfile2=$base.u + tmpdepfile3=$dir.libs/$base.u + "$@" -Wc,-M + else + tmpdepfile1=$dir$base.u + tmpdepfile2=$dir$base.u + tmpdepfile3=$dir$base.u + "$@" -M + fi + stat=$? + if test $stat -ne 0; then + rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" + exit $stat + fi + + for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" + do + test -f "$tmpdepfile" && break + done + aix_post_process_depfile + ;; + +tcc) + # tcc (Tiny C Compiler) understand '-MD -MF file' since version 0.9.26 + # FIXME: That version still under development at the moment of writing. + # Make that this statement remains true also for stable, released + # versions. + # It will wrap lines (doesn't matter whether long or short) with a + # trailing '\', as in: + # + # foo.o : \ + # foo.c \ + # foo.h \ + # + # It will put a trailing '\' even on the last line, and will use leading + # spaces rather than leading tabs (at least since its commit 0394caf7 + # "Emit spaces for -MD"). + "$@" -MD -MF "$tmpdepfile" + stat=$? + if test $stat -ne 0; then + rm -f "$tmpdepfile" + exit $stat + fi + rm -f "$depfile" + # Each non-empty line is of the form 'foo.o : \' or ' dep.h \'. + # We have to change lines of the first kind to '$object: \'. + sed -e "s|.*:|$object :|" < "$tmpdepfile" > "$depfile" + # And for each line of the second kind, we have to emit a 'dep.h:' + # dummy dependency, to avoid the deleted-header problem. + sed -n -e 's|^ *\(.*\) *\\$|\1:|p' < "$tmpdepfile" >> "$depfile" + rm -f "$tmpdepfile" + ;; + +## The order of this option in the case statement is important, since the +## shell code in configure will try each of these formats in the order +## listed in this file. A plain '-MD' option would be understood by many +## compilers, so we must ensure this comes after the gcc and icc options. +pgcc) + # Portland's C compiler understands '-MD'. + # Will always output deps to 'file.d' where file is the root name of the + # source file under compilation, even if file resides in a subdirectory. + # The object file name does not affect the name of the '.d' file. + # pgcc 10.2 will output + # foo.o: sub/foo.c sub/foo.h + # and will wrap long lines using '\' : + # foo.o: sub/foo.c ... \ + # sub/foo.h ... \ + # ... + set_dir_from "$object" + # Use the source, not the object, to determine the base name, since + # that's sadly what pgcc will do too. + set_base_from "$source" + tmpdepfile=$base.d + + # For projects that build the same source file twice into different object + # files, the pgcc approach of using the *source* file root name can cause + # problems in parallel builds. Use a locking strategy to avoid stomping on + # the same $tmpdepfile. + lockdir=$base.d-lock + trap " + echo '$0: caught signal, cleaning up...' >&2 + rmdir '$lockdir' + exit 1 + " 1 2 13 15 + numtries=100 + i=$numtries + while test $i -gt 0; do + # mkdir is a portable test-and-set. + if mkdir "$lockdir" 2>/dev/null; then + # This process acquired the lock. + "$@" -MD + stat=$? + # Release the lock. + rmdir "$lockdir" + break + else + # If the lock is being held by a different process, wait + # until the winning process is done or we timeout. + while test -d "$lockdir" && test $i -gt 0; do + sleep 1 + i=`expr $i - 1` + done + fi + i=`expr $i - 1` + done + trap - 1 2 13 15 + if test $i -le 0; then + echo "$0: failed to acquire lock after $numtries attempts" >&2 + echo "$0: check lockdir '$lockdir'" >&2 + exit 1 + fi + + if test $stat -ne 0; then + rm -f "$tmpdepfile" + exit $stat + fi + rm -f "$depfile" + # Each line is of the form `foo.o: dependent.h', + # or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'. + # Do two passes, one to just change these to + # `$object: dependent.h' and one to simply `dependent.h:'. + sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile" + # Some versions of the HPUX 10.20 sed can't process this invocation + # correctly. Breaking it into two sed invocations is a workaround. + sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" \ + | sed -e 's/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +hp2) + # The "hp" stanza above does not work with aCC (C++) and HP's ia64 + # compilers, which have integrated preprocessors. The correct option + # to use with these is +Maked; it writes dependencies to a file named + # 'foo.d', which lands next to the object file, wherever that + # happens to be. + # Much of this is similar to the tru64 case; see comments there. + set_dir_from "$object" + set_base_from "$object" + if test "$libtool" = yes; then + tmpdepfile1=$dir$base.d + tmpdepfile2=$dir.libs/$base.d + "$@" -Wc,+Maked + else + tmpdepfile1=$dir$base.d + tmpdepfile2=$dir$base.d + "$@" +Maked + fi + stat=$? + if test $stat -ne 0; then + rm -f "$tmpdepfile1" "$tmpdepfile2" + exit $stat + fi + + for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" + do + test -f "$tmpdepfile" && break + done + if test -f "$tmpdepfile"; then + sed -e "s,^.*\.[$lower]*:,$object:," "$tmpdepfile" > "$depfile" + # Add 'dependent.h:' lines. + sed -ne '2,${ + s/^ *// + s/ \\*$// + s/$/:/ + p + }' "$tmpdepfile" >> "$depfile" + else + make_dummy_depfile + fi + rm -f "$tmpdepfile" "$tmpdepfile2" + ;; + +tru64) + # The Tru64 compiler uses -MD to generate dependencies as a side + # effect. 'cc -MD -o foo.o ...' puts the dependencies into 'foo.o.d'. + # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put + # dependencies in 'foo.d' instead, so we check for that too. + # Subdirectories are respected. + set_dir_from "$object" + set_base_from "$object" + + if test "$libtool" = yes; then + # Libtool generates 2 separate objects for the 2 libraries. These + # two compilations output dependencies in $dir.libs/$base.o.d and + # in $dir$base.o.d. We have to check for both files, because + # one of the two compilations can be disabled. We should prefer + # $dir$base.o.d over $dir.libs/$base.o.d because the latter is + # automatically cleaned when .libs/ is deleted, while ignoring + # the former would cause a distcleancheck panic. + tmpdepfile1=$dir$base.o.d # libtool 1.5 + tmpdepfile2=$dir.libs/$base.o.d # Likewise. + tmpdepfile3=$dir.libs/$base.d # Compaq CCC V6.2-504 + "$@" -Wc,-MD + else + tmpdepfile1=$dir$base.d + tmpdepfile2=$dir$base.d + tmpdepfile3=$dir$base.d + "$@" -MD + fi + + stat=$? + if test $stat -ne 0; then + rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" + exit $stat + fi + + for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" + do + test -f "$tmpdepfile" && break + done + # Same post-processing that is required for AIX mode. + aix_post_process_depfile + ;; + +msvc7) + if test "$libtool" = yes; then + showIncludes=-Wc,-showIncludes + else + showIncludes=-showIncludes + fi + "$@" $showIncludes > "$tmpdepfile" + stat=$? + grep -v '^Note: including file: ' "$tmpdepfile" + if test $stat -ne 0; then + rm -f "$tmpdepfile" + exit $stat + fi + rm -f "$depfile" + echo "$object : \\" > "$depfile" + # The first sed program below extracts the file names and escapes + # backslashes for cygpath. The second sed program outputs the file + # name when reading, but also accumulates all include files in the + # hold buffer in order to output them again at the end. This only + # works with sed implementations that can handle large buffers. + sed < "$tmpdepfile" -n ' +/^Note: including file: *\(.*\)/ { + s//\1/ + s/\\/\\\\/g + p +}' | $cygpath_u | sort -u | sed -n ' +s/ /\\ /g +s/\(.*\)/'"$tab"'\1 \\/p +s/.\(.*\) \\/\1:/ +H +$ { + s/.*/'"$tab"'/ + G + p +}' >> "$depfile" + echo >> "$depfile" # make sure the fragment doesn't end with a backslash + rm -f "$tmpdepfile" + ;; + +msvc7msys) + # This case exists only to let depend.m4 do its work. It works by + # looking at the text of this script. This case will never be run, + # since it is checked for above. + exit 1 + ;; + +#nosideeffect) + # This comment above is used by automake to tell side-effect + # dependency tracking mechanisms from slower ones. + +dashmstdout) + # Important note: in order to support this mode, a compiler *must* + # always write the preprocessed file to stdout, regardless of -o. + "$@" || exit $? + + # Remove the call to Libtool. + if test "$libtool" = yes; then + while test "X$1" != 'X--mode=compile'; do + shift + done + shift + fi + + # Remove '-o $object'. + IFS=" " + for arg + do + case $arg in + -o) + shift + ;; + $object) + shift + ;; + *) + set fnord "$@" "$arg" + shift # fnord + shift # $arg + ;; + esac + done + + test -z "$dashmflag" && dashmflag=-M + # Require at least two characters before searching for ':' + # in the target name. This is to cope with DOS-style filenames: + # a dependency such as 'c:/foo/bar' could be seen as target 'c' otherwise. + "$@" $dashmflag | + sed "s|^[$tab ]*[^:$tab ][^:][^:]*:[$tab ]*|$object: |" > "$tmpdepfile" + rm -f "$depfile" + cat < "$tmpdepfile" > "$depfile" + # Some versions of the HPUX 10.20 sed can't process this sed invocation + # correctly. Breaking it into two sed invocations is a workaround. + tr ' ' "$nl" < "$tmpdepfile" \ + | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \ + | sed -e 's/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +dashXmstdout) + # This case only exists to satisfy depend.m4. It is never actually + # run, as this mode is specially recognized in the preamble. + exit 1 + ;; + +makedepend) + "$@" || exit $? + # Remove any Libtool call + if test "$libtool" = yes; then + while test "X$1" != 'X--mode=compile'; do + shift + done + shift + fi + # X makedepend + shift + cleared=no eat=no + for arg + do + case $cleared in + no) + set ""; shift + cleared=yes ;; + esac + if test $eat = yes; then + eat=no + continue + fi + case "$arg" in + -D*|-I*) + set fnord "$@" "$arg"; shift ;; + # Strip any option that makedepend may not understand. Remove + # the object too, otherwise makedepend will parse it as a source file. + -arch) + eat=yes ;; + -*|$object) + ;; + *) + set fnord "$@" "$arg"; shift ;; + esac + done + obj_suffix=`echo "$object" | sed 's/^.*\././'` + touch "$tmpdepfile" + ${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@" + rm -f "$depfile" + # makedepend may prepend the VPATH from the source file name to the object. + # No need to regex-escape $object, excess matching of '.' is harmless. + sed "s|^.*\($object *:\)|\1|" "$tmpdepfile" > "$depfile" + # Some versions of the HPUX 10.20 sed can't process the last invocation + # correctly. Breaking it into two sed invocations is a workaround. + sed '1,2d' "$tmpdepfile" \ + | tr ' ' "$nl" \ + | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \ + | sed -e 's/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" "$tmpdepfile".bak + ;; + +cpp) + # Important note: in order to support this mode, a compiler *must* + # always write the preprocessed file to stdout. + "$@" || exit $? + + # Remove the call to Libtool. + if test "$libtool" = yes; then + while test "X$1" != 'X--mode=compile'; do + shift + done + shift + fi + + # Remove '-o $object'. + IFS=" " + for arg + do + case $arg in + -o) + shift + ;; + $object) + shift + ;; + *) + set fnord "$@" "$arg" + shift # fnord + shift # $arg + ;; + esac + done + + "$@" -E \ + | sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \ + -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \ + | sed '$ s: \\$::' > "$tmpdepfile" + rm -f "$depfile" + echo "$object : \\" > "$depfile" + cat < "$tmpdepfile" >> "$depfile" + sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +msvisualcpp) + # Important note: in order to support this mode, a compiler *must* + # always write the preprocessed file to stdout. + "$@" || exit $? + + # Remove the call to Libtool. + if test "$libtool" = yes; then + while test "X$1" != 'X--mode=compile'; do + shift + done + shift + fi + + IFS=" " + for arg + do + case "$arg" in + -o) + shift + ;; + $object) + shift + ;; + "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI") + set fnord "$@" + shift + shift + ;; + *) + set fnord "$@" "$arg" + shift + shift + ;; + esac + done + "$@" -E 2>/dev/null | + sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile" + rm -f "$depfile" + echo "$object : \\" > "$depfile" + sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::'"$tab"'\1 \\:p' >> "$depfile" + echo "$tab" >> "$depfile" + sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +msvcmsys) + # This case exists only to let depend.m4 do its work. It works by + # looking at the text of this script. This case will never be run, + # since it is checked for above. + exit 1 + ;; + +none) + exec "$@" + ;; + +*) + echo "Unknown depmode $depmode" 1>&2 + exit 1 + ;; +esac + +exit 0 + +# Local Variables: +# mode: shell-script +# sh-indentation: 2 +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "scriptversion=" +# time-stamp-format: "%:y-%02m-%02d.%02H" +# time-stamp-time-zone: "UTC" +# time-stamp-end: "; # UTC" +# End: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/install-sh b/native_client/ctcdecode/third_party/openfst-1.6.7/install-sh new file mode 100755 index 0000000000..377bb8687f --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/install-sh @@ -0,0 +1,527 @@ +#!/bin/sh +# install - install a program, script, or datafile + +scriptversion=2011-11-20.07; # UTC + +# This originates from X11R5 (mit/util/scripts/install.sh), which was +# later released in X11R6 (xc/config/util/install.sh) with the +# following copyright and license. +# +# Copyright (C) 1994 X Consortium +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to +# deal in the Software without restriction, including without limitation the +# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +# sell copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC- +# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# +# Except as contained in this notice, the name of the X Consortium shall not +# be used in advertising or otherwise to promote the sale, use or other deal- +# ings in this Software without prior written authorization from the X Consor- +# tium. +# +# +# FSF changes to this file are in the public domain. +# +# Calling this script install-sh is preferred over install.sh, to prevent +# 'make' implicit rules from creating a file called install from it +# when there is no Makefile. +# +# This script is compatible with the BSD install script, but was written +# from scratch. + +nl=' +' +IFS=" "" $nl" + +# set DOITPROG to echo to test this script + +# Don't use :- since 4.3BSD and earlier shells don't like it. +doit=${DOITPROG-} +if test -z "$doit"; then + doit_exec=exec +else + doit_exec=$doit +fi + +# Put in absolute file names if you don't have them in your path; +# or use environment vars. + +chgrpprog=${CHGRPPROG-chgrp} +chmodprog=${CHMODPROG-chmod} +chownprog=${CHOWNPROG-chown} +cmpprog=${CMPPROG-cmp} +cpprog=${CPPROG-cp} +mkdirprog=${MKDIRPROG-mkdir} +mvprog=${MVPROG-mv} +rmprog=${RMPROG-rm} +stripprog=${STRIPPROG-strip} + +posix_glob='?' +initialize_posix_glob=' + test "$posix_glob" != "?" || { + if (set -f) 2>/dev/null; then + posix_glob= + else + posix_glob=: + fi + } +' + +posix_mkdir= + +# Desired mode of installed file. +mode=0755 + +chgrpcmd= +chmodcmd=$chmodprog +chowncmd= +mvcmd=$mvprog +rmcmd="$rmprog -f" +stripcmd= + +src= +dst= +dir_arg= +dst_arg= + +copy_on_change=false +no_target_directory= + +usage="\ +Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE + or: $0 [OPTION]... SRCFILES... DIRECTORY + or: $0 [OPTION]... -t DIRECTORY SRCFILES... + or: $0 [OPTION]... -d DIRECTORIES... + +In the 1st form, copy SRCFILE to DSTFILE. +In the 2nd and 3rd, copy all SRCFILES to DIRECTORY. +In the 4th, create DIRECTORIES. + +Options: + --help display this help and exit. + --version display version info and exit. + + -c (ignored) + -C install only if different (preserve the last data modification time) + -d create directories instead of installing files. + -g GROUP $chgrpprog installed files to GROUP. + -m MODE $chmodprog installed files to MODE. + -o USER $chownprog installed files to USER. + -s $stripprog installed files. + -t DIRECTORY install into DIRECTORY. + -T report an error if DSTFILE is a directory. + +Environment variables override the default commands: + CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG + RMPROG STRIPPROG +" + +while test $# -ne 0; do + case $1 in + -c) ;; + + -C) copy_on_change=true;; + + -d) dir_arg=true;; + + -g) chgrpcmd="$chgrpprog $2" + shift;; + + --help) echo "$usage"; exit $?;; + + -m) mode=$2 + case $mode in + *' '* | *' '* | *' +'* | *'*'* | *'?'* | *'['*) + echo "$0: invalid mode: $mode" >&2 + exit 1;; + esac + shift;; + + -o) chowncmd="$chownprog $2" + shift;; + + -s) stripcmd=$stripprog;; + + -t) dst_arg=$2 + # Protect names problematic for 'test' and other utilities. + case $dst_arg in + -* | [=\(\)!]) dst_arg=./$dst_arg;; + esac + shift;; + + -T) no_target_directory=true;; + + --version) echo "$0 $scriptversion"; exit $?;; + + --) shift + break;; + + -*) echo "$0: invalid option: $1" >&2 + exit 1;; + + *) break;; + esac + shift +done + +if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then + # When -d is used, all remaining arguments are directories to create. + # When -t is used, the destination is already specified. + # Otherwise, the last argument is the destination. Remove it from $@. + for arg + do + if test -n "$dst_arg"; then + # $@ is not empty: it contains at least $arg. + set fnord "$@" "$dst_arg" + shift # fnord + fi + shift # arg + dst_arg=$arg + # Protect names problematic for 'test' and other utilities. + case $dst_arg in + -* | [=\(\)!]) dst_arg=./$dst_arg;; + esac + done +fi + +if test $# -eq 0; then + if test -z "$dir_arg"; then + echo "$0: no input file specified." >&2 + exit 1 + fi + # It's OK to call 'install-sh -d' without argument. + # This can happen when creating conditional directories. + exit 0 +fi + +if test -z "$dir_arg"; then + do_exit='(exit $ret); exit $ret' + trap "ret=129; $do_exit" 1 + trap "ret=130; $do_exit" 2 + trap "ret=141; $do_exit" 13 + trap "ret=143; $do_exit" 15 + + # Set umask so as not to create temps with too-generous modes. + # However, 'strip' requires both read and write access to temps. + case $mode in + # Optimize common cases. + *644) cp_umask=133;; + *755) cp_umask=22;; + + *[0-7]) + if test -z "$stripcmd"; then + u_plus_rw= + else + u_plus_rw='% 200' + fi + cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;; + *) + if test -z "$stripcmd"; then + u_plus_rw= + else + u_plus_rw=,u+rw + fi + cp_umask=$mode$u_plus_rw;; + esac +fi + +for src +do + # Protect names problematic for 'test' and other utilities. + case $src in + -* | [=\(\)!]) src=./$src;; + esac + + if test -n "$dir_arg"; then + dst=$src + dstdir=$dst + test -d "$dstdir" + dstdir_status=$? + else + + # Waiting for this to be detected by the "$cpprog $src $dsttmp" command + # might cause directories to be created, which would be especially bad + # if $src (and thus $dsttmp) contains '*'. + if test ! -f "$src" && test ! -d "$src"; then + echo "$0: $src does not exist." >&2 + exit 1 + fi + + if test -z "$dst_arg"; then + echo "$0: no destination specified." >&2 + exit 1 + fi + dst=$dst_arg + + # If destination is a directory, append the input filename; won't work + # if double slashes aren't ignored. + if test -d "$dst"; then + if test -n "$no_target_directory"; then + echo "$0: $dst_arg: Is a directory" >&2 + exit 1 + fi + dstdir=$dst + dst=$dstdir/`basename "$src"` + dstdir_status=0 + else + # Prefer dirname, but fall back on a substitute if dirname fails. + dstdir=` + (dirname "$dst") 2>/dev/null || + expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$dst" : 'X\(//\)[^/]' \| \ + X"$dst" : 'X\(//\)$' \| \ + X"$dst" : 'X\(/\)' \| . 2>/dev/null || + echo X"$dst" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q' + ` + + test -d "$dstdir" + dstdir_status=$? + fi + fi + + obsolete_mkdir_used=false + + if test $dstdir_status != 0; then + case $posix_mkdir in + '') + # Create intermediate dirs using mode 755 as modified by the umask. + # This is like FreeBSD 'install' as of 1997-10-28. + umask=`umask` + case $stripcmd.$umask in + # Optimize common cases. + *[2367][2367]) mkdir_umask=$umask;; + .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;; + + *[0-7]) + mkdir_umask=`expr $umask + 22 \ + - $umask % 100 % 40 + $umask % 20 \ + - $umask % 10 % 4 + $umask % 2 + `;; + *) mkdir_umask=$umask,go-w;; + esac + + # With -d, create the new directory with the user-specified mode. + # Otherwise, rely on $mkdir_umask. + if test -n "$dir_arg"; then + mkdir_mode=-m$mode + else + mkdir_mode= + fi + + posix_mkdir=false + case $umask in + *[123567][0-7][0-7]) + # POSIX mkdir -p sets u+wx bits regardless of umask, which + # is incompatible with FreeBSD 'install' when (umask & 300) != 0. + ;; + *) + tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$ + trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0 + + if (umask $mkdir_umask && + exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1 + then + if test -z "$dir_arg" || { + # Check for POSIX incompatibilities with -m. + # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or + # other-writable bit of parent directory when it shouldn't. + # FreeBSD 6.1 mkdir -m -p sets mode of existing directory. + ls_ld_tmpdir=`ls -ld "$tmpdir"` + case $ls_ld_tmpdir in + d????-?r-*) different_mode=700;; + d????-?--*) different_mode=755;; + *) false;; + esac && + $mkdirprog -m$different_mode -p -- "$tmpdir" && { + ls_ld_tmpdir_1=`ls -ld "$tmpdir"` + test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1" + } + } + then posix_mkdir=: + fi + rmdir "$tmpdir/d" "$tmpdir" + else + # Remove any dirs left behind by ancient mkdir implementations. + rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null + fi + trap '' 0;; + esac;; + esac + + if + $posix_mkdir && ( + umask $mkdir_umask && + $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir" + ) + then : + else + + # The umask is ridiculous, or mkdir does not conform to POSIX, + # or it failed possibly due to a race condition. Create the + # directory the slow way, step by step, checking for races as we go. + + case $dstdir in + /*) prefix='/';; + [-=\(\)!]*) prefix='./';; + *) prefix='';; + esac + + eval "$initialize_posix_glob" + + oIFS=$IFS + IFS=/ + $posix_glob set -f + set fnord $dstdir + shift + $posix_glob set +f + IFS=$oIFS + + prefixes= + + for d + do + test X"$d" = X && continue + + prefix=$prefix$d + if test -d "$prefix"; then + prefixes= + else + if $posix_mkdir; then + (umask=$mkdir_umask && + $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break + # Don't fail if two instances are running concurrently. + test -d "$prefix" || exit 1 + else + case $prefix in + *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;; + *) qprefix=$prefix;; + esac + prefixes="$prefixes '$qprefix'" + fi + fi + prefix=$prefix/ + done + + if test -n "$prefixes"; then + # Don't fail if two instances are running concurrently. + (umask $mkdir_umask && + eval "\$doit_exec \$mkdirprog $prefixes") || + test -d "$dstdir" || exit 1 + obsolete_mkdir_used=true + fi + fi + fi + + if test -n "$dir_arg"; then + { test -z "$chowncmd" || $doit $chowncmd "$dst"; } && + { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } && + { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false || + test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1 + else + + # Make a couple of temp file names in the proper directory. + dsttmp=$dstdir/_inst.$$_ + rmtmp=$dstdir/_rm.$$_ + + # Trap to clean up those temp files at exit. + trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0 + + # Copy the file name to the temp name. + (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") && + + # and set any options; do chmod last to preserve setuid bits. + # + # If any of these fail, we abort the whole thing. If we want to + # ignore errors from any of these, just make sure not to ignore + # errors from the above "$doit $cpprog $src $dsttmp" command. + # + { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } && + { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } && + { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } && + { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } && + + # If -C, don't bother to copy if it wouldn't change the file. + if $copy_on_change && + old=`LC_ALL=C ls -dlL "$dst" 2>/dev/null` && + new=`LC_ALL=C ls -dlL "$dsttmp" 2>/dev/null` && + + eval "$initialize_posix_glob" && + $posix_glob set -f && + set X $old && old=:$2:$4:$5:$6 && + set X $new && new=:$2:$4:$5:$6 && + $posix_glob set +f && + + test "$old" = "$new" && + $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1 + then + rm -f "$dsttmp" + else + # Rename the file to the real destination. + $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null || + + # The rename failed, perhaps because mv can't rename something else + # to itself, or perhaps because mv is so ancient that it does not + # support -f. + { + # Now remove or move aside any old file at destination location. + # We try this two ways since rm can't unlink itself on some + # systems and the destination file might be busy for other + # reasons. In this case, the final cleanup might fail but the new + # file should still install successfully. + { + test ! -f "$dst" || + $doit $rmcmd -f "$dst" 2>/dev/null || + { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null && + { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; } + } || + { echo "$0: cannot unlink or rename $dst" >&2 + (exit 1); exit 1 + } + } && + + # Now rename the file to the real destination. + $doit $mvcmd "$dsttmp" "$dst" + } + fi || exit 1 + + trap '' 0 + fi +done + +# Local variables: +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "scriptversion=" +# time-stamp-format: "%:y-%02m-%02d.%02H" +# time-stamp-time-zone: "UTC" +# time-stamp-end: "; # UTC" +# End: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/ltmain.sh b/native_client/ctcdecode/third_party/openfst-1.6.7/ltmain.sh new file mode 100644 index 0000000000..a356acafa4 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/ltmain.sh @@ -0,0 +1,9661 @@ + +# libtool (GNU libtool) 2.4.2 +# Written by Gordon Matzigkeit , 1996 + +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, +# 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. +# This is free software; see the source for copying conditions. There is NO +# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + +# GNU Libtool is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# As a special exception to the GNU General Public License, +# if you distribute this file as part of a program or library that +# is built using GNU Libtool, you may include this file under the +# same distribution terms that you use for the rest of that program. +# +# GNU Libtool is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Libtool; see the file COPYING. If not, a copy +# can be downloaded from http://www.gnu.org/licenses/gpl.html, +# or obtained by writing to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +# Usage: $progname [OPTION]... [MODE-ARG]... +# +# Provide generalized library-building support services. +# +# --config show all configuration variables +# --debug enable verbose shell tracing +# -n, --dry-run display commands without modifying any files +# --features display basic configuration information and exit +# --mode=MODE use operation mode MODE +# --preserve-dup-deps don't remove duplicate dependency libraries +# --quiet, --silent don't print informational messages +# --no-quiet, --no-silent +# print informational messages (default) +# --no-warn don't display warning messages +# --tag=TAG use configuration variables from tag TAG +# -v, --verbose print more informational messages than default +# --no-verbose don't print the extra informational messages +# --version print version information +# -h, --help, --help-all print short, long, or detailed help message +# +# MODE must be one of the following: +# +# clean remove files from the build directory +# compile compile a source file into a libtool object +# execute automatically set library path, then run a program +# finish complete the installation of libtool libraries +# install install libraries or executables +# link create a library or an executable +# uninstall remove libraries from an installed directory +# +# MODE-ARGS vary depending on the MODE. When passed as first option, +# `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that. +# Try `$progname --help --mode=MODE' for a more detailed description of MODE. +# +# When reporting a bug, please describe a test case to reproduce it and +# include the following information: +# +# host-triplet: $host +# shell: $SHELL +# compiler: $LTCC +# compiler flags: $LTCFLAGS +# linker: $LD (gnu? $with_gnu_ld) +# $progname: (GNU libtool) 2.4.2 Debian-2.4.2-1.7ubuntu1 +# automake: $automake_version +# autoconf: $autoconf_version +# +# Report bugs to . +# GNU libtool home page: . +# General help using GNU software: . + +PROGRAM=libtool +PACKAGE=libtool +VERSION="2.4.2 Debian-2.4.2-1.7ubuntu1" +TIMESTAMP="" +package_revision=1.3337 + +# Be Bourne compatible +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then + emulate sh + NULLCMD=: + # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' + setopt NO_GLOB_SUBST +else + case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac +fi +BIN_SH=xpg4; export BIN_SH # for Tru64 +DUALCASE=1; export DUALCASE # for MKS sh + +# A function that is used when there is no print builtin or printf. +func_fallback_echo () +{ + eval 'cat <<_LTECHO_EOF +$1 +_LTECHO_EOF' +} + +# NLS nuisances: We save the old values to restore during execute mode. +lt_user_locale= +lt_safe_locale= +for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES +do + eval "if test \"\${$lt_var+set}\" = set; then + save_$lt_var=\$$lt_var + $lt_var=C + export $lt_var + lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\" + lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\" + fi" +done +LC_ALL=C +LANGUAGE=C +export LANGUAGE LC_ALL + +$lt_unset CDPATH + + +# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh +# is ksh but when the shell is invoked as "sh" and the current value of +# the _XPG environment variable is not equal to 1 (one), the special +# positional parameter $0, within a function call, is the name of the +# function. +progpath="$0" + + + +: ${CP="cp -f"} +test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'} +: ${MAKE="make"} +: ${MKDIR="mkdir"} +: ${MV="mv -f"} +: ${RM="rm -f"} +: ${SHELL="${CONFIG_SHELL-/bin/sh}"} +: ${Xsed="$SED -e 1s/^X//"} + +# Global variables: +EXIT_SUCCESS=0 +EXIT_FAILURE=1 +EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing. +EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake. + +exit_status=$EXIT_SUCCESS + +# Make sure IFS has a sensible default +lt_nl=' +' +IFS=" $lt_nl" + +dirname="s,/[^/]*$,," +basename="s,^.*/,," + +# func_dirname file append nondir_replacement +# Compute the dirname of FILE. If nonempty, add APPEND to the result, +# otherwise set result to NONDIR_REPLACEMENT. +func_dirname () +{ + func_dirname_result=`$ECHO "${1}" | $SED "$dirname"` + if test "X$func_dirname_result" = "X${1}"; then + func_dirname_result="${3}" + else + func_dirname_result="$func_dirname_result${2}" + fi +} # func_dirname may be replaced by extended shell implementation + + +# func_basename file +func_basename () +{ + func_basename_result=`$ECHO "${1}" | $SED "$basename"` +} # func_basename may be replaced by extended shell implementation + + +# func_dirname_and_basename file append nondir_replacement +# perform func_basename and func_dirname in a single function +# call: +# dirname: Compute the dirname of FILE. If nonempty, +# add APPEND to the result, otherwise set result +# to NONDIR_REPLACEMENT. +# value returned in "$func_dirname_result" +# basename: Compute filename of FILE. +# value retuned in "$func_basename_result" +# Implementation must be kept synchronized with func_dirname +# and func_basename. For efficiency, we do not delegate to +# those functions but instead duplicate the functionality here. +func_dirname_and_basename () +{ + # Extract subdirectory from the argument. + func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"` + if test "X$func_dirname_result" = "X${1}"; then + func_dirname_result="${3}" + else + func_dirname_result="$func_dirname_result${2}" + fi + func_basename_result=`$ECHO "${1}" | $SED -e "$basename"` +} # func_dirname_and_basename may be replaced by extended shell implementation + + +# func_stripname prefix suffix name +# strip PREFIX and SUFFIX off of NAME. +# PREFIX and SUFFIX must not contain globbing or regex special +# characters, hashes, percent signs, but SUFFIX may contain a leading +# dot (in which case that matches only a dot). +# func_strip_suffix prefix name +func_stripname () +{ + case ${2} in + .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;; + *) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;; + esac +} # func_stripname may be replaced by extended shell implementation + + +# These SED scripts presuppose an absolute path with a trailing slash. +pathcar='s,^/\([^/]*\).*$,\1,' +pathcdr='s,^/[^/]*,,' +removedotparts=':dotsl + s@/\./@/@g + t dotsl + s,/\.$,/,' +collapseslashes='s@/\{1,\}@/@g' +finalslash='s,/*$,/,' + +# func_normal_abspath PATH +# Remove doubled-up and trailing slashes, "." path components, +# and cancel out any ".." path components in PATH after making +# it an absolute path. +# value returned in "$func_normal_abspath_result" +func_normal_abspath () +{ + # Start from root dir and reassemble the path. + func_normal_abspath_result= + func_normal_abspath_tpath=$1 + func_normal_abspath_altnamespace= + case $func_normal_abspath_tpath in + "") + # Empty path, that just means $cwd. + func_stripname '' '/' "`pwd`" + func_normal_abspath_result=$func_stripname_result + return + ;; + # The next three entries are used to spot a run of precisely + # two leading slashes without using negated character classes; + # we take advantage of case's first-match behaviour. + ///*) + # Unusual form of absolute path, do nothing. + ;; + //*) + # Not necessarily an ordinary path; POSIX reserves leading '//' + # and for example Cygwin uses it to access remote file shares + # over CIFS/SMB, so we conserve a leading double slash if found. + func_normal_abspath_altnamespace=/ + ;; + /*) + # Absolute path, do nothing. + ;; + *) + # Relative path, prepend $cwd. + func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath + ;; + esac + # Cancel out all the simple stuff to save iterations. We also want + # the path to end with a slash for ease of parsing, so make sure + # there is one (and only one) here. + func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \ + -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"` + while :; do + # Processed it all yet? + if test "$func_normal_abspath_tpath" = / ; then + # If we ascended to the root using ".." the result may be empty now. + if test -z "$func_normal_abspath_result" ; then + func_normal_abspath_result=/ + fi + break + fi + func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \ + -e "$pathcar"` + func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \ + -e "$pathcdr"` + # Figure out what to do with it + case $func_normal_abspath_tcomponent in + "") + # Trailing empty path component, ignore it. + ;; + ..) + # Parent dir; strip last assembled component from result. + func_dirname "$func_normal_abspath_result" + func_normal_abspath_result=$func_dirname_result + ;; + *) + # Actual path component, append it. + func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent + ;; + esac + done + # Restore leading double-slash if one was found on entry. + func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result +} + +# func_relative_path SRCDIR DSTDIR +# generates a relative path from SRCDIR to DSTDIR, with a trailing +# slash if non-empty, suitable for immediately appending a filename +# without needing to append a separator. +# value returned in "$func_relative_path_result" +func_relative_path () +{ + func_relative_path_result= + func_normal_abspath "$1" + func_relative_path_tlibdir=$func_normal_abspath_result + func_normal_abspath "$2" + func_relative_path_tbindir=$func_normal_abspath_result + + # Ascend the tree starting from libdir + while :; do + # check if we have found a prefix of bindir + case $func_relative_path_tbindir in + $func_relative_path_tlibdir) + # found an exact match + func_relative_path_tcancelled= + break + ;; + $func_relative_path_tlibdir*) + # found a matching prefix + func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir" + func_relative_path_tcancelled=$func_stripname_result + if test -z "$func_relative_path_result"; then + func_relative_path_result=. + fi + break + ;; + *) + func_dirname $func_relative_path_tlibdir + func_relative_path_tlibdir=${func_dirname_result} + if test "x$func_relative_path_tlibdir" = x ; then + # Have to descend all the way to the root! + func_relative_path_result=../$func_relative_path_result + func_relative_path_tcancelled=$func_relative_path_tbindir + break + fi + func_relative_path_result=../$func_relative_path_result + ;; + esac + done + + # Now calculate path; take care to avoid doubling-up slashes. + func_stripname '' '/' "$func_relative_path_result" + func_relative_path_result=$func_stripname_result + func_stripname '/' '/' "$func_relative_path_tcancelled" + if test "x$func_stripname_result" != x ; then + func_relative_path_result=${func_relative_path_result}/${func_stripname_result} + fi + + # Normalisation. If bindir is libdir, return empty string, + # else relative path ending with a slash; either way, target + # file name can be directly appended. + if test ! -z "$func_relative_path_result"; then + func_stripname './' '' "$func_relative_path_result/" + func_relative_path_result=$func_stripname_result + fi +} + +# The name of this program: +func_dirname_and_basename "$progpath" +progname=$func_basename_result + +# Make sure we have an absolute path for reexecution: +case $progpath in + [\\/]*|[A-Za-z]:\\*) ;; + *[\\/]*) + progdir=$func_dirname_result + progdir=`cd "$progdir" && pwd` + progpath="$progdir/$progname" + ;; + *) + save_IFS="$IFS" + IFS=${PATH_SEPARATOR-:} + for progdir in $PATH; do + IFS="$save_IFS" + test -x "$progdir/$progname" && break + done + IFS="$save_IFS" + test -n "$progdir" || progdir=`pwd` + progpath="$progdir/$progname" + ;; +esac + +# Sed substitution that helps us do robust quoting. It backslashifies +# metacharacters that are still active within double-quoted strings. +Xsed="${SED}"' -e 1s/^X//' +sed_quote_subst='s/\([`"$\\]\)/\\\1/g' + +# Same as above, but do not quote variable references. +double_quote_subst='s/\(["`\\]\)/\\\1/g' + +# Sed substitution that turns a string into a regex matching for the +# string literally. +sed_make_literal_regex='s,[].[^$\\*\/],\\&,g' + +# Sed substitution that converts a w32 file name or path +# which contains forward slashes, into one that contains +# (escaped) backslashes. A very naive implementation. +lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g' + +# Re-`\' parameter expansions in output of double_quote_subst that were +# `\'-ed in input to the same. If an odd number of `\' preceded a '$' +# in input to double_quote_subst, that '$' was protected from expansion. +# Since each input `\' is now two `\'s, look for any number of runs of +# four `\'s followed by two `\'s and then a '$'. `\' that '$'. +bs='\\' +bs2='\\\\' +bs4='\\\\\\\\' +dollar='\$' +sed_double_backslash="\ + s/$bs4/&\\ +/g + s/^$bs2$dollar/$bs&/ + s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g + s/\n//g" + +# Standard options: +opt_dry_run=false +opt_help=false +opt_quiet=false +opt_verbose=false +opt_warning=: + +# func_echo arg... +# Echo program name prefixed message, along with the current mode +# name if it has been set yet. +func_echo () +{ + $ECHO "$progname: ${opt_mode+$opt_mode: }$*" +} + +# func_verbose arg... +# Echo program name prefixed message in verbose mode only. +func_verbose () +{ + $opt_verbose && func_echo ${1+"$@"} + + # A bug in bash halts the script if the last line of a function + # fails when set -e is in force, so we need another command to + # work around that: + : +} + +# func_echo_all arg... +# Invoke $ECHO with all args, space-separated. +func_echo_all () +{ + $ECHO "$*" +} + +# func_error arg... +# Echo program name prefixed message to standard error. +func_error () +{ + $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2 +} + +# func_warning arg... +# Echo program name prefixed warning message to standard error. +func_warning () +{ + $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2 + + # bash bug again: + : +} + +# func_fatal_error arg... +# Echo program name prefixed message to standard error, and exit. +func_fatal_error () +{ + func_error ${1+"$@"} + exit $EXIT_FAILURE +} + +# func_fatal_help arg... +# Echo program name prefixed message to standard error, followed by +# a help hint, and exit. +func_fatal_help () +{ + func_error ${1+"$@"} + func_fatal_error "$help" +} +help="Try \`$progname --help' for more information." ## default + + +# func_grep expression filename +# Check whether EXPRESSION matches any line of FILENAME, without output. +func_grep () +{ + $GREP "$1" "$2" >/dev/null 2>&1 +} + + +# func_mkdir_p directory-path +# Make sure the entire path to DIRECTORY-PATH is available. +func_mkdir_p () +{ + my_directory_path="$1" + my_dir_list= + + if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then + + # Protect directory names starting with `-' + case $my_directory_path in + -*) my_directory_path="./$my_directory_path" ;; + esac + + # While some portion of DIR does not yet exist... + while test ! -d "$my_directory_path"; do + # ...make a list in topmost first order. Use a colon delimited + # list incase some portion of path contains whitespace. + my_dir_list="$my_directory_path:$my_dir_list" + + # If the last portion added has no slash in it, the list is done + case $my_directory_path in */*) ;; *) break ;; esac + + # ...otherwise throw away the child directory and loop + my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"` + done + my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'` + + save_mkdir_p_IFS="$IFS"; IFS=':' + for my_dir in $my_dir_list; do + IFS="$save_mkdir_p_IFS" + # mkdir can fail with a `File exist' error if two processes + # try to create one of the directories concurrently. Don't + # stop in that case! + $MKDIR "$my_dir" 2>/dev/null || : + done + IFS="$save_mkdir_p_IFS" + + # Bail out if we (or some other process) failed to create a directory. + test -d "$my_directory_path" || \ + func_fatal_error "Failed to create \`$1'" + fi +} + + +# func_mktempdir [string] +# Make a temporary directory that won't clash with other running +# libtool processes, and avoids race conditions if possible. If +# given, STRING is the basename for that directory. +func_mktempdir () +{ + my_template="${TMPDIR-/tmp}/${1-$progname}" + + if test "$opt_dry_run" = ":"; then + # Return a directory name, but don't create it in dry-run mode + my_tmpdir="${my_template}-$$" + else + + # If mktemp works, use that first and foremost + my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null` + + if test ! -d "$my_tmpdir"; then + # Failing that, at least try and use $RANDOM to avoid a race + my_tmpdir="${my_template}-${RANDOM-0}$$" + + save_mktempdir_umask=`umask` + umask 0077 + $MKDIR "$my_tmpdir" + umask $save_mktempdir_umask + fi + + # If we're not in dry-run mode, bomb out on failure + test -d "$my_tmpdir" || \ + func_fatal_error "cannot create temporary directory \`$my_tmpdir'" + fi + + $ECHO "$my_tmpdir" +} + + +# func_quote_for_eval arg +# Aesthetically quote ARG to be evaled later. +# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT +# is double-quoted, suitable for a subsequent eval, whereas +# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters +# which are still active within double quotes backslashified. +func_quote_for_eval () +{ + case $1 in + *[\\\`\"\$]*) + func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;; + *) + func_quote_for_eval_unquoted_result="$1" ;; + esac + + case $func_quote_for_eval_unquoted_result in + # Double-quote args containing shell metacharacters to delay + # word splitting, command substitution and and variable + # expansion for a subsequent eval. + # Many Bourne shells cannot handle close brackets correctly + # in scan sets, so we specify it separately. + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\"" + ;; + *) + func_quote_for_eval_result="$func_quote_for_eval_unquoted_result" + esac +} + + +# func_quote_for_expand arg +# Aesthetically quote ARG to be evaled later; same as above, +# but do not quote variable references. +func_quote_for_expand () +{ + case $1 in + *[\\\`\"]*) + my_arg=`$ECHO "$1" | $SED \ + -e "$double_quote_subst" -e "$sed_double_backslash"` ;; + *) + my_arg="$1" ;; + esac + + case $my_arg in + # Double-quote args containing shell metacharacters to delay + # word splitting and command substitution for a subsequent eval. + # Many Bourne shells cannot handle close brackets correctly + # in scan sets, so we specify it separately. + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + my_arg="\"$my_arg\"" + ;; + esac + + func_quote_for_expand_result="$my_arg" +} + + +# func_show_eval cmd [fail_exp] +# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is +# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP +# is given, then evaluate it. +func_show_eval () +{ + my_cmd="$1" + my_fail_exp="${2-:}" + + ${opt_silent-false} || { + func_quote_for_expand "$my_cmd" + eval "func_echo $func_quote_for_expand_result" + } + + if ${opt_dry_run-false}; then :; else + eval "$my_cmd" + my_status=$? + if test "$my_status" -eq 0; then :; else + eval "(exit $my_status); $my_fail_exp" + fi + fi +} + + +# func_show_eval_locale cmd [fail_exp] +# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is +# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP +# is given, then evaluate it. Use the saved locale for evaluation. +func_show_eval_locale () +{ + my_cmd="$1" + my_fail_exp="${2-:}" + + ${opt_silent-false} || { + func_quote_for_expand "$my_cmd" + eval "func_echo $func_quote_for_expand_result" + } + + if ${opt_dry_run-false}; then :; else + eval "$lt_user_locale + $my_cmd" + my_status=$? + eval "$lt_safe_locale" + if test "$my_status" -eq 0; then :; else + eval "(exit $my_status); $my_fail_exp" + fi + fi +} + +# func_tr_sh +# Turn $1 into a string suitable for a shell variable name. +# Result is stored in $func_tr_sh_result. All characters +# not in the set a-zA-Z0-9_ are replaced with '_'. Further, +# if $1 begins with a digit, a '_' is prepended as well. +func_tr_sh () +{ + case $1 in + [0-9]* | *[!a-zA-Z0-9_]*) + func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'` + ;; + * ) + func_tr_sh_result=$1 + ;; + esac +} + + +# func_version +# Echo version message to standard output and exit. +func_version () +{ + $opt_debug + + $SED -n '/(C)/!b go + :more + /\./!{ + N + s/\n# / / + b more + } + :go + /^# '$PROGRAM' (GNU /,/# warranty; / { + s/^# // + s/^# *$// + s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/ + p + }' < "$progpath" + exit $? +} + +# func_usage +# Echo short help message to standard output and exit. +func_usage () +{ + $opt_debug + + $SED -n '/^# Usage:/,/^# *.*--help/ { + s/^# // + s/^# *$// + s/\$progname/'$progname'/ + p + }' < "$progpath" + echo + $ECHO "run \`$progname --help | more' for full usage" + exit $? +} + +# func_help [NOEXIT] +# Echo long help message to standard output and exit, +# unless 'noexit' is passed as argument. +func_help () +{ + $opt_debug + + $SED -n '/^# Usage:/,/# Report bugs to/ { + :print + s/^# // + s/^# *$// + s*\$progname*'$progname'* + s*\$host*'"$host"'* + s*\$SHELL*'"$SHELL"'* + s*\$LTCC*'"$LTCC"'* + s*\$LTCFLAGS*'"$LTCFLAGS"'* + s*\$LD*'"$LD"'* + s/\$with_gnu_ld/'"$with_gnu_ld"'/ + s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/ + s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/ + p + d + } + /^# .* home page:/b print + /^# General help using/b print + ' < "$progpath" + ret=$? + if test -z "$1"; then + exit $ret + fi +} + +# func_missing_arg argname +# Echo program name prefixed message to standard error and set global +# exit_cmd. +func_missing_arg () +{ + $opt_debug + + func_error "missing argument for $1." + exit_cmd=exit +} + + +# func_split_short_opt shortopt +# Set func_split_short_opt_name and func_split_short_opt_arg shell +# variables after splitting SHORTOPT after the 2nd character. +func_split_short_opt () +{ + my_sed_short_opt='1s/^\(..\).*$/\1/;q' + my_sed_short_rest='1s/^..\(.*\)$/\1/;q' + + func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"` + func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"` +} # func_split_short_opt may be replaced by extended shell implementation + + +# func_split_long_opt longopt +# Set func_split_long_opt_name and func_split_long_opt_arg shell +# variables after splitting LONGOPT at the `=' sign. +func_split_long_opt () +{ + my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q' + my_sed_long_arg='1s/^--[^=]*=//' + + func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"` + func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"` +} # func_split_long_opt may be replaced by extended shell implementation + +exit_cmd=: + + + + + +magic="%%%MAGIC variable%%%" +magic_exe="%%%MAGIC EXE variable%%%" + +# Global variables. +nonopt= +preserve_args= +lo2o="s/\\.lo\$/.${objext}/" +o2lo="s/\\.${objext}\$/.lo/" +extracted_archives= +extracted_serial=0 + +# If this variable is set in any of the actions, the command in it +# will be execed at the end. This prevents here-documents from being +# left over by shells. +exec_cmd= + +# func_append var value +# Append VALUE to the end of shell variable VAR. +func_append () +{ + eval "${1}=\$${1}\${2}" +} # func_append may be replaced by extended shell implementation + +# func_append_quoted var value +# Quote VALUE and append to the end of shell variable VAR, separated +# by a space. +func_append_quoted () +{ + func_quote_for_eval "${2}" + eval "${1}=\$${1}\\ \$func_quote_for_eval_result" +} # func_append_quoted may be replaced by extended shell implementation + + +# func_arith arithmetic-term... +func_arith () +{ + func_arith_result=`expr "${@}"` +} # func_arith may be replaced by extended shell implementation + + +# func_len string +# STRING may not start with a hyphen. +func_len () +{ + func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len` +} # func_len may be replaced by extended shell implementation + + +# func_lo2o object +func_lo2o () +{ + func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"` +} # func_lo2o may be replaced by extended shell implementation + + +# func_xform libobj-or-source +func_xform () +{ + func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'` +} # func_xform may be replaced by extended shell implementation + + +# func_fatal_configuration arg... +# Echo program name prefixed message to standard error, followed by +# a configuration failure hint, and exit. +func_fatal_configuration () +{ + func_error ${1+"$@"} + func_error "See the $PACKAGE documentation for more information." + func_fatal_error "Fatal configuration error." +} + + +# func_config +# Display the configuration for all the tags in this script. +func_config () +{ + re_begincf='^# ### BEGIN LIBTOOL' + re_endcf='^# ### END LIBTOOL' + + # Default configuration. + $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath" + + # Now print the configurations for the tags. + for tagname in $taglist; do + $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath" + done + + exit $? +} + +# func_features +# Display the features supported by this script. +func_features () +{ + echo "host: $host" + if test "$build_libtool_libs" = yes; then + echo "enable shared libraries" + else + echo "disable shared libraries" + fi + if test "$build_old_libs" = yes; then + echo "enable static libraries" + else + echo "disable static libraries" + fi + + exit $? +} + +# func_enable_tag tagname +# Verify that TAGNAME is valid, and either flag an error and exit, or +# enable the TAGNAME tag. We also add TAGNAME to the global $taglist +# variable here. +func_enable_tag () +{ + # Global variable: + tagname="$1" + + re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$" + re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$" + sed_extractcf="/$re_begincf/,/$re_endcf/p" + + # Validate tagname. + case $tagname in + *[!-_A-Za-z0-9,/]*) + func_fatal_error "invalid tag name: $tagname" + ;; + esac + + # Don't test for the "default" C tag, as we know it's + # there but not specially marked. + case $tagname in + CC) ;; + *) + if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then + taglist="$taglist $tagname" + + # Evaluate the configuration. Be careful to quote the path + # and the sed script, to avoid splitting on whitespace, but + # also don't use non-portable quotes within backquotes within + # quotes we have to do it in 2 steps: + extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"` + eval "$extractedcf" + else + func_error "ignoring unknown tag $tagname" + fi + ;; + esac +} + +# func_check_version_match +# Ensure that we are using m4 macros, and libtool script from the same +# release of libtool. +func_check_version_match () +{ + if test "$package_revision" != "$macro_revision"; then + if test "$VERSION" != "$macro_version"; then + if test -z "$macro_version"; then + cat >&2 <<_LT_EOF +$progname: Version mismatch error. This is $PACKAGE $VERSION, but the +$progname: definition of this LT_INIT comes from an older release. +$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION +$progname: and run autoconf again. +_LT_EOF + else + cat >&2 <<_LT_EOF +$progname: Version mismatch error. This is $PACKAGE $VERSION, but the +$progname: definition of this LT_INIT comes from $PACKAGE $macro_version. +$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION +$progname: and run autoconf again. +_LT_EOF + fi + else + cat >&2 <<_LT_EOF +$progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision, +$progname: but the definition of this LT_INIT comes from revision $macro_revision. +$progname: You should recreate aclocal.m4 with macros from revision $package_revision +$progname: of $PACKAGE $VERSION and run autoconf again. +_LT_EOF + fi + + exit $EXIT_MISMATCH + fi +} + + +# Shorthand for --mode=foo, only valid as the first argument +case $1 in +clean|clea|cle|cl) + shift; set dummy --mode clean ${1+"$@"}; shift + ;; +compile|compil|compi|comp|com|co|c) + shift; set dummy --mode compile ${1+"$@"}; shift + ;; +execute|execut|execu|exec|exe|ex|e) + shift; set dummy --mode execute ${1+"$@"}; shift + ;; +finish|finis|fini|fin|fi|f) + shift; set dummy --mode finish ${1+"$@"}; shift + ;; +install|instal|insta|inst|ins|in|i) + shift; set dummy --mode install ${1+"$@"}; shift + ;; +link|lin|li|l) + shift; set dummy --mode link ${1+"$@"}; shift + ;; +uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u) + shift; set dummy --mode uninstall ${1+"$@"}; shift + ;; +esac + + + +# Option defaults: +opt_debug=: +opt_dry_run=false +opt_config=false +opt_preserve_dup_deps=false +opt_features=false +opt_finish=false +opt_help=false +opt_help_all=false +opt_silent=: +opt_warning=: +opt_verbose=: +opt_silent=false +opt_verbose=false + + +# Parse options once, thoroughly. This comes as soon as possible in the +# script to make things like `--version' happen as quickly as we can. +{ + # this just eases exit handling + while test $# -gt 0; do + opt="$1" + shift + case $opt in + --debug|-x) opt_debug='set -x' + func_echo "enabling shell trace mode" + $opt_debug + ;; + --dry-run|--dryrun|-n) + opt_dry_run=: + ;; + --config) + opt_config=: +func_config + ;; + --dlopen|-dlopen) + optarg="$1" + opt_dlopen="${opt_dlopen+$opt_dlopen +}$optarg" + shift + ;; + --preserve-dup-deps) + opt_preserve_dup_deps=: + ;; + --features) + opt_features=: +func_features + ;; + --finish) + opt_finish=: +set dummy --mode finish ${1+"$@"}; shift + ;; + --help) + opt_help=: + ;; + --help-all) + opt_help_all=: +opt_help=': help-all' + ;; + --mode) + test $# = 0 && func_missing_arg $opt && break + optarg="$1" + opt_mode="$optarg" +case $optarg in + # Valid mode arguments: + clean|compile|execute|finish|install|link|relink|uninstall) ;; + + # Catch anything else as an error + *) func_error "invalid argument for $opt" + exit_cmd=exit + break + ;; +esac + shift + ;; + --no-silent|--no-quiet) + opt_silent=false +func_append preserve_args " $opt" + ;; + --no-warning|--no-warn) + opt_warning=false +func_append preserve_args " $opt" + ;; + --no-verbose) + opt_verbose=false +func_append preserve_args " $opt" + ;; + --silent|--quiet) + opt_silent=: +func_append preserve_args " $opt" + opt_verbose=false + ;; + --verbose|-v) + opt_verbose=: +func_append preserve_args " $opt" +opt_silent=false + ;; + --tag) + test $# = 0 && func_missing_arg $opt && break + optarg="$1" + opt_tag="$optarg" +func_append preserve_args " $opt $optarg" +func_enable_tag "$optarg" + shift + ;; + + -\?|-h) func_usage ;; + --help) func_help ;; + --version) func_version ;; + + # Separate optargs to long options: + --*=*) + func_split_long_opt "$opt" + set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"} + shift + ;; + + # Separate non-argument short options: + -\?*|-h*|-n*|-v*) + func_split_short_opt "$opt" + set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"} + shift + ;; + + --) break ;; + -*) func_fatal_help "unrecognized option \`$opt'" ;; + *) set dummy "$opt" ${1+"$@"}; shift; break ;; + esac + done + + # Validate options: + + # save first non-option argument + if test "$#" -gt 0; then + nonopt="$opt" + shift + fi + + # preserve --debug + test "$opt_debug" = : || func_append preserve_args " --debug" + + case $host in + *cygwin* | *mingw* | *pw32* | *cegcc*) + # don't eliminate duplications in $postdeps and $predeps + opt_duplicate_compiler_generated_deps=: + ;; + *) + opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps + ;; + esac + + $opt_help || { + # Sanity checks first: + func_check_version_match + + if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then + func_fatal_configuration "not configured to build any kind of library" + fi + + # Darwin sucks + eval std_shrext=\"$shrext_cmds\" + + # Only execute mode is allowed to have -dlopen flags. + if test -n "$opt_dlopen" && test "$opt_mode" != execute; then + func_error "unrecognized option \`-dlopen'" + $ECHO "$help" 1>&2 + exit $EXIT_FAILURE + fi + + # Change the help message to a mode-specific one. + generic_help="$help" + help="Try \`$progname --help --mode=$opt_mode' for more information." + } + + + # Bail if the options were screwed + $exit_cmd $EXIT_FAILURE +} + + + + +## ----------- ## +## Main. ## +## ----------- ## + +# func_lalib_p file +# True iff FILE is a libtool `.la' library or `.lo' object file. +# This function is only a basic sanity check; it will hardly flush out +# determined imposters. +func_lalib_p () +{ + test -f "$1" && + $SED -e 4q "$1" 2>/dev/null \ + | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1 +} + +# func_lalib_unsafe_p file +# True iff FILE is a libtool `.la' library or `.lo' object file. +# This function implements the same check as func_lalib_p without +# resorting to external programs. To this end, it redirects stdin and +# closes it afterwards, without saving the original file descriptor. +# As a safety measure, use it only where a negative result would be +# fatal anyway. Works if `file' does not exist. +func_lalib_unsafe_p () +{ + lalib_p=no + if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then + for lalib_p_l in 1 2 3 4 + do + read lalib_p_line + case "$lalib_p_line" in + \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;; + esac + done + exec 0<&5 5<&- + fi + test "$lalib_p" = yes +} + +# func_ltwrapper_script_p file +# True iff FILE is a libtool wrapper script +# This function is only a basic sanity check; it will hardly flush out +# determined imposters. +func_ltwrapper_script_p () +{ + func_lalib_p "$1" +} + +# func_ltwrapper_executable_p file +# True iff FILE is a libtool wrapper executable +# This function is only a basic sanity check; it will hardly flush out +# determined imposters. +func_ltwrapper_executable_p () +{ + func_ltwrapper_exec_suffix= + case $1 in + *.exe) ;; + *) func_ltwrapper_exec_suffix=.exe ;; + esac + $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1 +} + +# func_ltwrapper_scriptname file +# Assumes file is an ltwrapper_executable +# uses $file to determine the appropriate filename for a +# temporary ltwrapper_script. +func_ltwrapper_scriptname () +{ + func_dirname_and_basename "$1" "" "." + func_stripname '' '.exe' "$func_basename_result" + func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper" +} + +# func_ltwrapper_p file +# True iff FILE is a libtool wrapper script or wrapper executable +# This function is only a basic sanity check; it will hardly flush out +# determined imposters. +func_ltwrapper_p () +{ + func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1" +} + + +# func_execute_cmds commands fail_cmd +# Execute tilde-delimited COMMANDS. +# If FAIL_CMD is given, eval that upon failure. +# FAIL_CMD may read-access the current command in variable CMD! +func_execute_cmds () +{ + $opt_debug + save_ifs=$IFS; IFS='~' + for cmd in $1; do + IFS=$save_ifs + eval cmd=\"$cmd\" + func_show_eval "$cmd" "${2-:}" + done + IFS=$save_ifs +} + + +# func_source file +# Source FILE, adding directory component if necessary. +# Note that it is not necessary on cygwin/mingw to append a dot to +# FILE even if both FILE and FILE.exe exist: automatic-append-.exe +# behavior happens only for exec(3), not for open(2)! Also, sourcing +# `FILE.' does not work on cygwin managed mounts. +func_source () +{ + $opt_debug + case $1 in + */* | *\\*) . "$1" ;; + *) . "./$1" ;; + esac +} + + +# func_resolve_sysroot PATH +# Replace a leading = in PATH with a sysroot. Store the result into +# func_resolve_sysroot_result +func_resolve_sysroot () +{ + func_resolve_sysroot_result=$1 + case $func_resolve_sysroot_result in + =*) + func_stripname '=' '' "$func_resolve_sysroot_result" + func_resolve_sysroot_result=$lt_sysroot$func_stripname_result + ;; + esac +} + +# func_replace_sysroot PATH +# If PATH begins with the sysroot, replace it with = and +# store the result into func_replace_sysroot_result. +func_replace_sysroot () +{ + case "$lt_sysroot:$1" in + ?*:"$lt_sysroot"*) + func_stripname "$lt_sysroot" '' "$1" + func_replace_sysroot_result="=$func_stripname_result" + ;; + *) + # Including no sysroot. + func_replace_sysroot_result=$1 + ;; + esac +} + +# func_infer_tag arg +# Infer tagged configuration to use if any are available and +# if one wasn't chosen via the "--tag" command line option. +# Only attempt this if the compiler in the base compile +# command doesn't match the default compiler. +# arg is usually of the form 'gcc ...' +func_infer_tag () +{ + $opt_debug + if test -n "$available_tags" && test -z "$tagname"; then + CC_quoted= + for arg in $CC; do + func_append_quoted CC_quoted "$arg" + done + CC_expanded=`func_echo_all $CC` + CC_quoted_expanded=`func_echo_all $CC_quoted` + case $@ in + # Blanks in the command may have been stripped by the calling shell, + # but not from the CC environment variable when configure was run. + " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \ + " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;; + # Blanks at the start of $base_compile will cause this to fail + # if we don't check for them as well. + *) + for z in $available_tags; do + if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then + # Evaluate the configuration. + eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`" + CC_quoted= + for arg in $CC; do + # Double-quote args containing other shell metacharacters. + func_append_quoted CC_quoted "$arg" + done + CC_expanded=`func_echo_all $CC` + CC_quoted_expanded=`func_echo_all $CC_quoted` + case "$@ " in + " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \ + " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) + # The compiler in the base compile command matches + # the one in the tagged configuration. + # Assume this is the tagged configuration we want. + tagname=$z + break + ;; + esac + fi + done + # If $tagname still isn't set, then no tagged configuration + # was found and let the user know that the "--tag" command + # line option must be used. + if test -z "$tagname"; then + func_echo "unable to infer tagged configuration" + func_fatal_error "specify a tag with \`--tag'" +# else +# func_verbose "using $tagname tagged configuration" + fi + ;; + esac + fi +} + + + +# func_write_libtool_object output_name pic_name nonpic_name +# Create a libtool object file (analogous to a ".la" file), +# but don't create it if we're doing a dry run. +func_write_libtool_object () +{ + write_libobj=${1} + if test "$build_libtool_libs" = yes; then + write_lobj=\'${2}\' + else + write_lobj=none + fi + + if test "$build_old_libs" = yes; then + write_oldobj=\'${3}\' + else + write_oldobj=none + fi + + $opt_dry_run || { + cat >${write_libobj}T </dev/null` + if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then + func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" | + $SED -e "$lt_sed_naive_backslashify"` + else + func_convert_core_file_wine_to_w32_result= + fi + fi +} +# end: func_convert_core_file_wine_to_w32 + + +# func_convert_core_path_wine_to_w32 ARG +# Helper function used by path conversion functions when $build is *nix, and +# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly +# configured wine environment available, with the winepath program in $build's +# $PATH. Assumes ARG has no leading or trailing path separator characters. +# +# ARG is path to be converted from $build format to win32. +# Result is available in $func_convert_core_path_wine_to_w32_result. +# Unconvertible file (directory) names in ARG are skipped; if no directory names +# are convertible, then the result may be empty. +func_convert_core_path_wine_to_w32 () +{ + $opt_debug + # unfortunately, winepath doesn't convert paths, only file names + func_convert_core_path_wine_to_w32_result="" + if test -n "$1"; then + oldIFS=$IFS + IFS=: + for func_convert_core_path_wine_to_w32_f in $1; do + IFS=$oldIFS + func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f" + if test -n "$func_convert_core_file_wine_to_w32_result" ; then + if test -z "$func_convert_core_path_wine_to_w32_result"; then + func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result" + else + func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result" + fi + fi + done + IFS=$oldIFS + fi +} +# end: func_convert_core_path_wine_to_w32 + + +# func_cygpath ARGS... +# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when +# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2) +# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or +# (2), returns the Cygwin file name or path in func_cygpath_result (input +# file name or path is assumed to be in w32 format, as previously converted +# from $build's *nix or MSYS format). In case (3), returns the w32 file name +# or path in func_cygpath_result (input file name or path is assumed to be in +# Cygwin format). Returns an empty string on error. +# +# ARGS are passed to cygpath, with the last one being the file name or path to +# be converted. +# +# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH +# environment variable; do not put it in $PATH. +func_cygpath () +{ + $opt_debug + if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then + func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null` + if test "$?" -ne 0; then + # on failure, ensure result is empty + func_cygpath_result= + fi + else + func_cygpath_result= + func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'" + fi +} +#end: func_cygpath + + +# func_convert_core_msys_to_w32 ARG +# Convert file name or path ARG from MSYS format to w32 format. Return +# result in func_convert_core_msys_to_w32_result. +func_convert_core_msys_to_w32 () +{ + $opt_debug + # awkward: cmd appends spaces to result + func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null | + $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"` +} +#end: func_convert_core_msys_to_w32 + + +# func_convert_file_check ARG1 ARG2 +# Verify that ARG1 (a file name in $build format) was converted to $host +# format in ARG2. Otherwise, emit an error message, but continue (resetting +# func_to_host_file_result to ARG1). +func_convert_file_check () +{ + $opt_debug + if test -z "$2" && test -n "$1" ; then + func_error "Could not determine host file name corresponding to" + func_error " \`$1'" + func_error "Continuing, but uninstalled executables may not work." + # Fallback: + func_to_host_file_result="$1" + fi +} +# end func_convert_file_check + + +# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH +# Verify that FROM_PATH (a path in $build format) was converted to $host +# format in TO_PATH. Otherwise, emit an error message, but continue, resetting +# func_to_host_file_result to a simplistic fallback value (see below). +func_convert_path_check () +{ + $opt_debug + if test -z "$4" && test -n "$3"; then + func_error "Could not determine the host path corresponding to" + func_error " \`$3'" + func_error "Continuing, but uninstalled executables may not work." + # Fallback. This is a deliberately simplistic "conversion" and + # should not be "improved". See libtool.info. + if test "x$1" != "x$2"; then + lt_replace_pathsep_chars="s|$1|$2|g" + func_to_host_path_result=`echo "$3" | + $SED -e "$lt_replace_pathsep_chars"` + else + func_to_host_path_result="$3" + fi + fi +} +# end func_convert_path_check + + +# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG +# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT +# and appending REPL if ORIG matches BACKPAT. +func_convert_path_front_back_pathsep () +{ + $opt_debug + case $4 in + $1 ) func_to_host_path_result="$3$func_to_host_path_result" + ;; + esac + case $4 in + $2 ) func_append func_to_host_path_result "$3" + ;; + esac +} +# end func_convert_path_front_back_pathsep + + +################################################## +# $build to $host FILE NAME CONVERSION FUNCTIONS # +################################################## +# invoked via `$to_host_file_cmd ARG' +# +# In each case, ARG is the path to be converted from $build to $host format. +# Result will be available in $func_to_host_file_result. + + +# func_to_host_file ARG +# Converts the file name ARG from $build format to $host format. Return result +# in func_to_host_file_result. +func_to_host_file () +{ + $opt_debug + $to_host_file_cmd "$1" +} +# end func_to_host_file + + +# func_to_tool_file ARG LAZY +# converts the file name ARG from $build format to toolchain format. Return +# result in func_to_tool_file_result. If the conversion in use is listed +# in (the comma separated) LAZY, no conversion takes place. +func_to_tool_file () +{ + $opt_debug + case ,$2, in + *,"$to_tool_file_cmd",*) + func_to_tool_file_result=$1 + ;; + *) + $to_tool_file_cmd "$1" + func_to_tool_file_result=$func_to_host_file_result + ;; + esac +} +# end func_to_tool_file + + +# func_convert_file_noop ARG +# Copy ARG to func_to_host_file_result. +func_convert_file_noop () +{ + func_to_host_file_result="$1" +} +# end func_convert_file_noop + + +# func_convert_file_msys_to_w32 ARG +# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic +# conversion to w32 is not available inside the cwrapper. Returns result in +# func_to_host_file_result. +func_convert_file_msys_to_w32 () +{ + $opt_debug + func_to_host_file_result="$1" + if test -n "$1"; then + func_convert_core_msys_to_w32 "$1" + func_to_host_file_result="$func_convert_core_msys_to_w32_result" + fi + func_convert_file_check "$1" "$func_to_host_file_result" +} +# end func_convert_file_msys_to_w32 + + +# func_convert_file_cygwin_to_w32 ARG +# Convert file name ARG from Cygwin to w32 format. Returns result in +# func_to_host_file_result. +func_convert_file_cygwin_to_w32 () +{ + $opt_debug + func_to_host_file_result="$1" + if test -n "$1"; then + # because $build is cygwin, we call "the" cygpath in $PATH; no need to use + # LT_CYGPATH in this case. + func_to_host_file_result=`cygpath -m "$1"` + fi + func_convert_file_check "$1" "$func_to_host_file_result" +} +# end func_convert_file_cygwin_to_w32 + + +# func_convert_file_nix_to_w32 ARG +# Convert file name ARG from *nix to w32 format. Requires a wine environment +# and a working winepath. Returns result in func_to_host_file_result. +func_convert_file_nix_to_w32 () +{ + $opt_debug + func_to_host_file_result="$1" + if test -n "$1"; then + func_convert_core_file_wine_to_w32 "$1" + func_to_host_file_result="$func_convert_core_file_wine_to_w32_result" + fi + func_convert_file_check "$1" "$func_to_host_file_result" +} +# end func_convert_file_nix_to_w32 + + +# func_convert_file_msys_to_cygwin ARG +# Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set. +# Returns result in func_to_host_file_result. +func_convert_file_msys_to_cygwin () +{ + $opt_debug + func_to_host_file_result="$1" + if test -n "$1"; then + func_convert_core_msys_to_w32 "$1" + func_cygpath -u "$func_convert_core_msys_to_w32_result" + func_to_host_file_result="$func_cygpath_result" + fi + func_convert_file_check "$1" "$func_to_host_file_result" +} +# end func_convert_file_msys_to_cygwin + + +# func_convert_file_nix_to_cygwin ARG +# Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed +# in a wine environment, working winepath, and LT_CYGPATH set. Returns result +# in func_to_host_file_result. +func_convert_file_nix_to_cygwin () +{ + $opt_debug + func_to_host_file_result="$1" + if test -n "$1"; then + # convert from *nix to w32, then use cygpath to convert from w32 to cygwin. + func_convert_core_file_wine_to_w32 "$1" + func_cygpath -u "$func_convert_core_file_wine_to_w32_result" + func_to_host_file_result="$func_cygpath_result" + fi + func_convert_file_check "$1" "$func_to_host_file_result" +} +# end func_convert_file_nix_to_cygwin + + +############################################# +# $build to $host PATH CONVERSION FUNCTIONS # +############################################# +# invoked via `$to_host_path_cmd ARG' +# +# In each case, ARG is the path to be converted from $build to $host format. +# The result will be available in $func_to_host_path_result. +# +# Path separators are also converted from $build format to $host format. If +# ARG begins or ends with a path separator character, it is preserved (but +# converted to $host format) on output. +# +# All path conversion functions are named using the following convention: +# file name conversion function : func_convert_file_X_to_Y () +# path conversion function : func_convert_path_X_to_Y () +# where, for any given $build/$host combination the 'X_to_Y' value is the +# same. If conversion functions are added for new $build/$host combinations, +# the two new functions must follow this pattern, or func_init_to_host_path_cmd +# will break. + + +# func_init_to_host_path_cmd +# Ensures that function "pointer" variable $to_host_path_cmd is set to the +# appropriate value, based on the value of $to_host_file_cmd. +to_host_path_cmd= +func_init_to_host_path_cmd () +{ + $opt_debug + if test -z "$to_host_path_cmd"; then + func_stripname 'func_convert_file_' '' "$to_host_file_cmd" + to_host_path_cmd="func_convert_path_${func_stripname_result}" + fi +} + + +# func_to_host_path ARG +# Converts the path ARG from $build format to $host format. Return result +# in func_to_host_path_result. +func_to_host_path () +{ + $opt_debug + func_init_to_host_path_cmd + $to_host_path_cmd "$1" +} +# end func_to_host_path + + +# func_convert_path_noop ARG +# Copy ARG to func_to_host_path_result. +func_convert_path_noop () +{ + func_to_host_path_result="$1" +} +# end func_convert_path_noop + + +# func_convert_path_msys_to_w32 ARG +# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic +# conversion to w32 is not available inside the cwrapper. Returns result in +# func_to_host_path_result. +func_convert_path_msys_to_w32 () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + # Remove leading and trailing path separator characters from ARG. MSYS + # behavior is inconsistent here; cygpath turns them into '.;' and ';.'; + # and winepath ignores them completely. + func_stripname : : "$1" + func_to_host_path_tmp1=$func_stripname_result + func_convert_core_msys_to_w32 "$func_to_host_path_tmp1" + func_to_host_path_result="$func_convert_core_msys_to_w32_result" + func_convert_path_check : ";" \ + "$func_to_host_path_tmp1" "$func_to_host_path_result" + func_convert_path_front_back_pathsep ":*" "*:" ";" "$1" + fi +} +# end func_convert_path_msys_to_w32 + + +# func_convert_path_cygwin_to_w32 ARG +# Convert path ARG from Cygwin to w32 format. Returns result in +# func_to_host_file_result. +func_convert_path_cygwin_to_w32 () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + # See func_convert_path_msys_to_w32: + func_stripname : : "$1" + func_to_host_path_tmp1=$func_stripname_result + func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"` + func_convert_path_check : ";" \ + "$func_to_host_path_tmp1" "$func_to_host_path_result" + func_convert_path_front_back_pathsep ":*" "*:" ";" "$1" + fi +} +# end func_convert_path_cygwin_to_w32 + + +# func_convert_path_nix_to_w32 ARG +# Convert path ARG from *nix to w32 format. Requires a wine environment and +# a working winepath. Returns result in func_to_host_file_result. +func_convert_path_nix_to_w32 () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + # See func_convert_path_msys_to_w32: + func_stripname : : "$1" + func_to_host_path_tmp1=$func_stripname_result + func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1" + func_to_host_path_result="$func_convert_core_path_wine_to_w32_result" + func_convert_path_check : ";" \ + "$func_to_host_path_tmp1" "$func_to_host_path_result" + func_convert_path_front_back_pathsep ":*" "*:" ";" "$1" + fi +} +# end func_convert_path_nix_to_w32 + + +# func_convert_path_msys_to_cygwin ARG +# Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set. +# Returns result in func_to_host_file_result. +func_convert_path_msys_to_cygwin () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + # See func_convert_path_msys_to_w32: + func_stripname : : "$1" + func_to_host_path_tmp1=$func_stripname_result + func_convert_core_msys_to_w32 "$func_to_host_path_tmp1" + func_cygpath -u -p "$func_convert_core_msys_to_w32_result" + func_to_host_path_result="$func_cygpath_result" + func_convert_path_check : : \ + "$func_to_host_path_tmp1" "$func_to_host_path_result" + func_convert_path_front_back_pathsep ":*" "*:" : "$1" + fi +} +# end func_convert_path_msys_to_cygwin + + +# func_convert_path_nix_to_cygwin ARG +# Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a +# a wine environment, working winepath, and LT_CYGPATH set. Returns result in +# func_to_host_file_result. +func_convert_path_nix_to_cygwin () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + # Remove leading and trailing path separator characters from + # ARG. msys behavior is inconsistent here, cygpath turns them + # into '.;' and ';.', and winepath ignores them completely. + func_stripname : : "$1" + func_to_host_path_tmp1=$func_stripname_result + func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1" + func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result" + func_to_host_path_result="$func_cygpath_result" + func_convert_path_check : : \ + "$func_to_host_path_tmp1" "$func_to_host_path_result" + func_convert_path_front_back_pathsep ":*" "*:" : "$1" + fi +} +# end func_convert_path_nix_to_cygwin + + +# func_mode_compile arg... +func_mode_compile () +{ + $opt_debug + # Get the compilation command and the source file. + base_compile= + srcfile="$nonopt" # always keep a non-empty value in "srcfile" + suppress_opt=yes + suppress_output= + arg_mode=normal + libobj= + later= + pie_flag= + + for arg + do + case $arg_mode in + arg ) + # do not "continue". Instead, add this to base_compile + lastarg="$arg" + arg_mode=normal + ;; + + target ) + libobj="$arg" + arg_mode=normal + continue + ;; + + normal ) + # Accept any command-line options. + case $arg in + -o) + test -n "$libobj" && \ + func_fatal_error "you cannot specify \`-o' more than once" + arg_mode=target + continue + ;; + + -pie | -fpie | -fPIE) + func_append pie_flag " $arg" + continue + ;; + + -shared | -static | -prefer-pic | -prefer-non-pic) + func_append later " $arg" + continue + ;; + + -no-suppress) + suppress_opt=no + continue + ;; + + -Xcompiler) + arg_mode=arg # the next one goes into the "base_compile" arg list + continue # The current "srcfile" will either be retained or + ;; # replaced later. I would guess that would be a bug. + + -Wc,*) + func_stripname '-Wc,' '' "$arg" + args=$func_stripname_result + lastarg= + save_ifs="$IFS"; IFS=',' + for arg in $args; do + IFS="$save_ifs" + func_append_quoted lastarg "$arg" + done + IFS="$save_ifs" + func_stripname ' ' '' "$lastarg" + lastarg=$func_stripname_result + + # Add the arguments to base_compile. + func_append base_compile " $lastarg" + continue + ;; + + *) + # Accept the current argument as the source file. + # The previous "srcfile" becomes the current argument. + # + lastarg="$srcfile" + srcfile="$arg" + ;; + esac # case $arg + ;; + esac # case $arg_mode + + # Aesthetically quote the previous argument. + func_append_quoted base_compile "$lastarg" + done # for arg + + case $arg_mode in + arg) + func_fatal_error "you must specify an argument for -Xcompile" + ;; + target) + func_fatal_error "you must specify a target with \`-o'" + ;; + *) + # Get the name of the library object. + test -z "$libobj" && { + func_basename "$srcfile" + libobj="$func_basename_result" + } + ;; + esac + + # Recognize several different file suffixes. + # If the user specifies -o file.o, it is replaced with file.lo + case $libobj in + *.[cCFSifmso] | \ + *.ada | *.adb | *.ads | *.asm | \ + *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \ + *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup) + func_xform "$libobj" + libobj=$func_xform_result + ;; + esac + + case $libobj in + *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;; + *) + func_fatal_error "cannot determine name of library object from \`$libobj'" + ;; + esac + + func_infer_tag $base_compile + + for arg in $later; do + case $arg in + -shared) + test "$build_libtool_libs" != yes && \ + func_fatal_configuration "can not build a shared library" + build_old_libs=no + continue + ;; + + -static) + build_libtool_libs=no + build_old_libs=yes + continue + ;; + + -prefer-pic) + pic_mode=yes + continue + ;; + + -prefer-non-pic) + pic_mode=no + continue + ;; + esac + done + + func_quote_for_eval "$libobj" + test "X$libobj" != "X$func_quote_for_eval_result" \ + && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \ + && func_warning "libobj name \`$libobj' may not contain shell special characters." + func_dirname_and_basename "$obj" "/" "" + objname="$func_basename_result" + xdir="$func_dirname_result" + lobj=${xdir}$objdir/$objname + + test -z "$base_compile" && \ + func_fatal_help "you must specify a compilation command" + + # Delete any leftover library objects. + if test "$build_old_libs" = yes; then + removelist="$obj $lobj $libobj ${libobj}T" + else + removelist="$lobj $libobj ${libobj}T" + fi + + # On Cygwin there's no "real" PIC flag so we must build both object types + case $host_os in + cygwin* | mingw* | pw32* | os2* | cegcc*) + pic_mode=default + ;; + esac + if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then + # non-PIC code in shared libraries is not supported + pic_mode=default + fi + + # Calculate the filename of the output object if compiler does + # not support -o with -c + if test "$compiler_c_o" = no; then + output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext} + lockfile="$output_obj.lock" + else + output_obj= + need_locks=no + lockfile= + fi + + # Lock this critical section if it is needed + # We use this script file to make the link, it avoids creating a new file + if test "$need_locks" = yes; then + until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do + func_echo "Waiting for $lockfile to be removed" + sleep 2 + done + elif test "$need_locks" = warn; then + if test -f "$lockfile"; then + $ECHO "\ +*** ERROR, $lockfile exists and contains: +`cat $lockfile 2>/dev/null` + +This indicates that another process is trying to use the same +temporary object file, and libtool could not work around it because +your compiler does not support \`-c' and \`-o' together. If you +repeat this compilation, it may succeed, by chance, but you had better +avoid parallel builds (make -j) in this platform, or get a better +compiler." + + $opt_dry_run || $RM $removelist + exit $EXIT_FAILURE + fi + func_append removelist " $output_obj" + $ECHO "$srcfile" > "$lockfile" + fi + + $opt_dry_run || $RM $removelist + func_append removelist " $lockfile" + trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15 + + func_to_tool_file "$srcfile" func_convert_file_msys_to_w32 + srcfile=$func_to_tool_file_result + func_quote_for_eval "$srcfile" + qsrcfile=$func_quote_for_eval_result + + # Only build a PIC object if we are building libtool libraries. + if test "$build_libtool_libs" = yes; then + # Without this assignment, base_compile gets emptied. + fbsd_hideous_sh_bug=$base_compile + + if test "$pic_mode" != no; then + command="$base_compile $qsrcfile $pic_flag" + else + # Don't build PIC code + command="$base_compile $qsrcfile" + fi + + func_mkdir_p "$xdir$objdir" + + if test -z "$output_obj"; then + # Place PIC objects in $objdir + func_append command " -o $lobj" + fi + + func_show_eval_locale "$command" \ + 'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE' + + if test "$need_locks" = warn && + test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then + $ECHO "\ +*** ERROR, $lockfile contains: +`cat $lockfile 2>/dev/null` + +but it should contain: +$srcfile + +This indicates that another process is trying to use the same +temporary object file, and libtool could not work around it because +your compiler does not support \`-c' and \`-o' together. If you +repeat this compilation, it may succeed, by chance, but you had better +avoid parallel builds (make -j) in this platform, or get a better +compiler." + + $opt_dry_run || $RM $removelist + exit $EXIT_FAILURE + fi + + # Just move the object if needed, then go on to compile the next one + if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then + func_show_eval '$MV "$output_obj" "$lobj"' \ + 'error=$?; $opt_dry_run || $RM $removelist; exit $error' + fi + + # Allow error messages only from the first compilation. + if test "$suppress_opt" = yes; then + suppress_output=' >/dev/null 2>&1' + fi + fi + + # Only build a position-dependent object if we build old libraries. + if test "$build_old_libs" = yes; then + if test "$pic_mode" != yes; then + # Don't build PIC code + command="$base_compile $qsrcfile$pie_flag" + else + command="$base_compile $qsrcfile $pic_flag" + fi + if test "$compiler_c_o" = yes; then + func_append command " -o $obj" + fi + + # Suppress compiler output if we already did a PIC compilation. + func_append command "$suppress_output" + func_show_eval_locale "$command" \ + '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' + + if test "$need_locks" = warn && + test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then + $ECHO "\ +*** ERROR, $lockfile contains: +`cat $lockfile 2>/dev/null` + +but it should contain: +$srcfile + +This indicates that another process is trying to use the same +temporary object file, and libtool could not work around it because +your compiler does not support \`-c' and \`-o' together. If you +repeat this compilation, it may succeed, by chance, but you had better +avoid parallel builds (make -j) in this platform, or get a better +compiler." + + $opt_dry_run || $RM $removelist + exit $EXIT_FAILURE + fi + + # Just move the object if needed + if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then + func_show_eval '$MV "$output_obj" "$obj"' \ + 'error=$?; $opt_dry_run || $RM $removelist; exit $error' + fi + fi + + $opt_dry_run || { + func_write_libtool_object "$libobj" "$objdir/$objname" "$objname" + + # Unlock the critical section if it was locked + if test "$need_locks" != no; then + removelist=$lockfile + $RM "$lockfile" + fi + } + + exit $EXIT_SUCCESS +} + +$opt_help || { + test "$opt_mode" = compile && func_mode_compile ${1+"$@"} +} + +func_mode_help () +{ + # We need to display help for each of the modes. + case $opt_mode in + "") + # Generic help is extracted from the usage comments + # at the start of this file. + func_help + ;; + + clean) + $ECHO \ +"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE... + +Remove files from the build directory. + +RM is the name of the program to use to delete files associated with each FILE +(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed +to RM. + +If FILE is a libtool library, object or program, all the files associated +with it are deleted. Otherwise, only FILE itself is deleted using RM." + ;; + + compile) + $ECHO \ +"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE + +Compile a source file into a libtool library object. + +This mode accepts the following additional options: + + -o OUTPUT-FILE set the output file name to OUTPUT-FILE + -no-suppress do not suppress compiler output for multiple passes + -prefer-pic try to build PIC objects only + -prefer-non-pic try to build non-PIC objects only + -shared do not build a \`.o' file suitable for static linking + -static only build a \`.o' file suitable for static linking + -Wc,FLAG pass FLAG directly to the compiler + +COMPILE-COMMAND is a command to be used in creating a \`standard' object file +from the given SOURCEFILE. + +The output file name is determined by removing the directory component from +SOURCEFILE, then substituting the C source code suffix \`.c' with the +library object suffix, \`.lo'." + ;; + + execute) + $ECHO \ +"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]... + +Automatically set library path, then run a program. + +This mode accepts the following additional options: + + -dlopen FILE add the directory containing FILE to the library path + +This mode sets the library path environment variable according to \`-dlopen' +flags. + +If any of the ARGS are libtool executable wrappers, then they are translated +into their corresponding uninstalled binary, and any of their required library +directories are added to the library path. + +Then, COMMAND is executed, with ARGS as arguments." + ;; + + finish) + $ECHO \ +"Usage: $progname [OPTION]... --mode=finish [LIBDIR]... + +Complete the installation of libtool libraries. + +Each LIBDIR is a directory that contains libtool libraries. + +The commands that this mode executes may require superuser privileges. Use +the \`--dry-run' option if you just want to see what would be executed." + ;; + + install) + $ECHO \ +"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND... + +Install executables or libraries. + +INSTALL-COMMAND is the installation command. The first component should be +either the \`install' or \`cp' program. + +The following components of INSTALL-COMMAND are treated specially: + + -inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation + +The rest of the components are interpreted as arguments to that command (only +BSD-compatible install options are recognized)." + ;; + + link) + $ECHO \ +"Usage: $progname [OPTION]... --mode=link LINK-COMMAND... + +Link object files or libraries together to form another library, or to +create an executable program. + +LINK-COMMAND is a command using the C compiler that you would use to create +a program from several object files. + +The following components of LINK-COMMAND are treated specially: + + -all-static do not do any dynamic linking at all + -avoid-version do not add a version suffix if possible + -bindir BINDIR specify path to binaries directory (for systems where + libraries must be found in the PATH setting at runtime) + -dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime + -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols + -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3) + -export-symbols SYMFILE + try to export only the symbols listed in SYMFILE + -export-symbols-regex REGEX + try to export only the symbols matching REGEX + -LLIBDIR search LIBDIR for required installed libraries + -lNAME OUTPUT-FILE requires the installed library libNAME + -module build a library that can dlopened + -no-fast-install disable the fast-install mode + -no-install link a not-installable executable + -no-undefined declare that a library does not refer to external symbols + -o OUTPUT-FILE create OUTPUT-FILE from the specified objects + -objectlist FILE Use a list of object files found in FILE to specify objects + -precious-files-regex REGEX + don't remove output files matching REGEX + -release RELEASE specify package release information + -rpath LIBDIR the created library will eventually be installed in LIBDIR + -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries + -shared only do dynamic linking of libtool libraries + -shrext SUFFIX override the standard shared library file extension + -static do not do any dynamic linking of uninstalled libtool libraries + -static-libtool-libs + do not do any dynamic linking of libtool libraries + -version-info CURRENT[:REVISION[:AGE]] + specify library version info [each variable defaults to 0] + -weak LIBNAME declare that the target provides the LIBNAME interface + -Wc,FLAG + -Xcompiler FLAG pass linker-specific FLAG directly to the compiler + -Wl,FLAG + -Xlinker FLAG pass linker-specific FLAG directly to the linker + -XCClinker FLAG pass link-specific FLAG to the compiler driver (CC) + +All other options (arguments beginning with \`-') are ignored. + +Every other argument is treated as a filename. Files ending in \`.la' are +treated as uninstalled libtool libraries, other files are standard or library +object files. + +If the OUTPUT-FILE ends in \`.la', then a libtool library is created, +only library objects (\`.lo' files) may be specified, and \`-rpath' is +required, except when creating a convenience library. + +If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created +using \`ar' and \`ranlib', or on Windows using \`lib'. + +If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file +is created, otherwise an executable program is created." + ;; + + uninstall) + $ECHO \ +"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE... + +Remove libraries from an installation directory. + +RM is the name of the program to use to delete files associated with each FILE +(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed +to RM. + +If FILE is a libtool library, all the files associated with it are deleted. +Otherwise, only FILE itself is deleted using RM." + ;; + + *) + func_fatal_help "invalid operation mode \`$opt_mode'" + ;; + esac + + echo + $ECHO "Try \`$progname --help' for more information about other modes." +} + +# Now that we've collected a possible --mode arg, show help if necessary +if $opt_help; then + if test "$opt_help" = :; then + func_mode_help + else + { + func_help noexit + for opt_mode in compile link execute install finish uninstall clean; do + func_mode_help + done + } | sed -n '1p; 2,$s/^Usage:/ or: /p' + { + func_help noexit + for opt_mode in compile link execute install finish uninstall clean; do + echo + func_mode_help + done + } | + sed '1d + /^When reporting/,/^Report/{ + H + d + } + $x + /information about other modes/d + /more detailed .*MODE/d + s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/' + fi + exit $? +fi + + +# func_mode_execute arg... +func_mode_execute () +{ + $opt_debug + # The first argument is the command name. + cmd="$nonopt" + test -z "$cmd" && \ + func_fatal_help "you must specify a COMMAND" + + # Handle -dlopen flags immediately. + for file in $opt_dlopen; do + test -f "$file" \ + || func_fatal_help "\`$file' is not a file" + + dir= + case $file in + *.la) + func_resolve_sysroot "$file" + file=$func_resolve_sysroot_result + + # Check to see that this really is a libtool archive. + func_lalib_unsafe_p "$file" \ + || func_fatal_help "\`$lib' is not a valid libtool archive" + + # Read the libtool library. + dlname= + library_names= + func_source "$file" + + # Skip this library if it cannot be dlopened. + if test -z "$dlname"; then + # Warn if it was a shared library. + test -n "$library_names" && \ + func_warning "\`$file' was not linked with \`-export-dynamic'" + continue + fi + + func_dirname "$file" "" "." + dir="$func_dirname_result" + + if test -f "$dir/$objdir/$dlname"; then + func_append dir "/$objdir" + else + if test ! -f "$dir/$dlname"; then + func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" + fi + fi + ;; + + *.lo) + # Just add the directory containing the .lo file. + func_dirname "$file" "" "." + dir="$func_dirname_result" + ;; + + *) + func_warning "\`-dlopen' is ignored for non-libtool libraries and objects" + continue + ;; + esac + + # Get the absolute pathname. + absdir=`cd "$dir" && pwd` + test -n "$absdir" && dir="$absdir" + + # Now add the directory to shlibpath_var. + if eval "test -z \"\$$shlibpath_var\""; then + eval "$shlibpath_var=\"\$dir\"" + else + eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\"" + fi + done + + # This variable tells wrapper scripts just to set shlibpath_var + # rather than running their programs. + libtool_execute_magic="$magic" + + # Check if any of the arguments is a wrapper script. + args= + for file + do + case $file in + -* | *.la | *.lo ) ;; + *) + # Do a test to see if this is really a libtool program. + if func_ltwrapper_script_p "$file"; then + func_source "$file" + # Transform arg to wrapped name. + file="$progdir/$program" + elif func_ltwrapper_executable_p "$file"; then + func_ltwrapper_scriptname "$file" + func_source "$func_ltwrapper_scriptname_result" + # Transform arg to wrapped name. + file="$progdir/$program" + fi + ;; + esac + # Quote arguments (to preserve shell metacharacters). + func_append_quoted args "$file" + done + + if test "X$opt_dry_run" = Xfalse; then + if test -n "$shlibpath_var"; then + # Export the shlibpath_var. + eval "export $shlibpath_var" + fi + + # Restore saved environment variables + for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES + do + eval "if test \"\${save_$lt_var+set}\" = set; then + $lt_var=\$save_$lt_var; export $lt_var + else + $lt_unset $lt_var + fi" + done + + # Now prepare to actually exec the command. + exec_cmd="\$cmd$args" + else + # Display what would be done. + if test -n "$shlibpath_var"; then + eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\"" + echo "export $shlibpath_var" + fi + $ECHO "$cmd$args" + exit $EXIT_SUCCESS + fi +} + +test "$opt_mode" = execute && func_mode_execute ${1+"$@"} + + +# func_mode_finish arg... +func_mode_finish () +{ + $opt_debug + libs= + libdirs= + admincmds= + + for opt in "$nonopt" ${1+"$@"} + do + if test -d "$opt"; then + func_append libdirs " $opt" + + elif test -f "$opt"; then + if func_lalib_unsafe_p "$opt"; then + func_append libs " $opt" + else + func_warning "\`$opt' is not a valid libtool archive" + fi + + else + func_fatal_error "invalid argument \`$opt'" + fi + done + + if test -n "$libs"; then + if test -n "$lt_sysroot"; then + sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"` + sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;" + else + sysroot_cmd= + fi + + # Remove sysroot references + if $opt_dry_run; then + for lib in $libs; do + echo "removing references to $lt_sysroot and \`=' prefixes from $lib" + done + else + tmpdir=`func_mktempdir` + for lib in $libs; do + sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \ + > $tmpdir/tmp-la + mv -f $tmpdir/tmp-la $lib + done + ${RM}r "$tmpdir" + fi + fi + + if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then + for libdir in $libdirs; do + if test -n "$finish_cmds"; then + # Do each command in the finish commands. + func_execute_cmds "$finish_cmds" 'admincmds="$admincmds +'"$cmd"'"' + fi + if test -n "$finish_eval"; then + # Do the single finish_eval. + eval cmds=\"$finish_eval\" + $opt_dry_run || eval "$cmds" || func_append admincmds " + $cmds" + fi + done + fi + + # Exit here if they wanted silent mode. + $opt_silent && exit $EXIT_SUCCESS + + if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then + echo "----------------------------------------------------------------------" + echo "Libraries have been installed in:" + for libdir in $libdirs; do + $ECHO " $libdir" + done + echo + echo "If you ever happen to want to link against installed libraries" + echo "in a given directory, LIBDIR, you must either use libtool, and" + echo "specify the full pathname of the library, or use the \`-LLIBDIR'" + echo "flag during linking and do at least one of the following:" + if test -n "$shlibpath_var"; then + echo " - add LIBDIR to the \`$shlibpath_var' environment variable" + echo " during execution" + fi + if test -n "$runpath_var"; then + echo " - add LIBDIR to the \`$runpath_var' environment variable" + echo " during linking" + fi + if test -n "$hardcode_libdir_flag_spec"; then + libdir=LIBDIR + eval flag=\"$hardcode_libdir_flag_spec\" + + $ECHO " - use the \`$flag' linker flag" + fi + if test -n "$admincmds"; then + $ECHO " - have your system administrator run these commands:$admincmds" + fi + if test -f /etc/ld.so.conf; then + echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'" + fi + echo + + echo "See any operating system documentation about shared libraries for" + case $host in + solaris2.[6789]|solaris2.1[0-9]) + echo "more information, such as the ld(1), crle(1) and ld.so(8) manual" + echo "pages." + ;; + *) + echo "more information, such as the ld(1) and ld.so(8) manual pages." + ;; + esac + echo "----------------------------------------------------------------------" + fi + exit $EXIT_SUCCESS +} + +test "$opt_mode" = finish && func_mode_finish ${1+"$@"} + + +# func_mode_install arg... +func_mode_install () +{ + $opt_debug + # There may be an optional sh(1) argument at the beginning of + # install_prog (especially on Windows NT). + if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh || + # Allow the use of GNU shtool's install command. + case $nonopt in *shtool*) :;; *) false;; esac; then + # Aesthetically quote it. + func_quote_for_eval "$nonopt" + install_prog="$func_quote_for_eval_result " + arg=$1 + shift + else + install_prog= + arg=$nonopt + fi + + # The real first argument should be the name of the installation program. + # Aesthetically quote it. + func_quote_for_eval "$arg" + func_append install_prog "$func_quote_for_eval_result" + install_shared_prog=$install_prog + case " $install_prog " in + *[\\\ /]cp\ *) install_cp=: ;; + *) install_cp=false ;; + esac + + # We need to accept at least all the BSD install flags. + dest= + files= + opts= + prev= + install_type= + isdir=no + stripme= + no_mode=: + for arg + do + arg2= + if test -n "$dest"; then + func_append files " $dest" + dest=$arg + continue + fi + + case $arg in + -d) isdir=yes ;; + -f) + if $install_cp; then :; else + prev=$arg + fi + ;; + -g | -m | -o) + prev=$arg + ;; + -s) + stripme=" -s" + continue + ;; + -*) + ;; + *) + # If the previous option needed an argument, then skip it. + if test -n "$prev"; then + if test "x$prev" = x-m && test -n "$install_override_mode"; then + arg2=$install_override_mode + no_mode=false + fi + prev= + else + dest=$arg + continue + fi + ;; + esac + + # Aesthetically quote the argument. + func_quote_for_eval "$arg" + func_append install_prog " $func_quote_for_eval_result" + if test -n "$arg2"; then + func_quote_for_eval "$arg2" + fi + func_append install_shared_prog " $func_quote_for_eval_result" + done + + test -z "$install_prog" && \ + func_fatal_help "you must specify an install program" + + test -n "$prev" && \ + func_fatal_help "the \`$prev' option requires an argument" + + if test -n "$install_override_mode" && $no_mode; then + if $install_cp; then :; else + func_quote_for_eval "$install_override_mode" + func_append install_shared_prog " -m $func_quote_for_eval_result" + fi + fi + + if test -z "$files"; then + if test -z "$dest"; then + func_fatal_help "no file or destination specified" + else + func_fatal_help "you must specify a destination" + fi + fi + + # Strip any trailing slash from the destination. + func_stripname '' '/' "$dest" + dest=$func_stripname_result + + # Check to see that the destination is a directory. + test -d "$dest" && isdir=yes + if test "$isdir" = yes; then + destdir="$dest" + destname= + else + func_dirname_and_basename "$dest" "" "." + destdir="$func_dirname_result" + destname="$func_basename_result" + + # Not a directory, so check to see that there is only one file specified. + set dummy $files; shift + test "$#" -gt 1 && \ + func_fatal_help "\`$dest' is not a directory" + fi + case $destdir in + [\\/]* | [A-Za-z]:[\\/]*) ;; + *) + for file in $files; do + case $file in + *.lo) ;; + *) + func_fatal_help "\`$destdir' must be an absolute directory name" + ;; + esac + done + ;; + esac + + # This variable tells wrapper scripts just to set variables rather + # than running their programs. + libtool_install_magic="$magic" + + staticlibs= + future_libdirs= + current_libdirs= + for file in $files; do + + # Do each installation. + case $file in + *.$libext) + # Do the static libraries later. + func_append staticlibs " $file" + ;; + + *.la) + func_resolve_sysroot "$file" + file=$func_resolve_sysroot_result + + # Check to see that this really is a libtool archive. + func_lalib_unsafe_p "$file" \ + || func_fatal_help "\`$file' is not a valid libtool archive" + + library_names= + old_library= + relink_command= + func_source "$file" + + # Add the libdir to current_libdirs if it is the destination. + if test "X$destdir" = "X$libdir"; then + case "$current_libdirs " in + *" $libdir "*) ;; + *) func_append current_libdirs " $libdir" ;; + esac + else + # Note the libdir as a future libdir. + case "$future_libdirs " in + *" $libdir "*) ;; + *) func_append future_libdirs " $libdir" ;; + esac + fi + + func_dirname "$file" "/" "" + dir="$func_dirname_result" + func_append dir "$objdir" + + if test -n "$relink_command"; then + # Determine the prefix the user has applied to our future dir. + inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"` + + # Don't allow the user to place us outside of our expected + # location b/c this prevents finding dependent libraries that + # are installed to the same prefix. + # At present, this check doesn't affect windows .dll's that + # are installed into $libdir/../bin (currently, that works fine) + # but it's something to keep an eye on. + test "$inst_prefix_dir" = "$destdir" && \ + func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir" + + if test -n "$inst_prefix_dir"; then + # Stick the inst_prefix_dir data into the link command. + relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"` + else + relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"` + fi + + func_warning "relinking \`$file'" + func_show_eval "$relink_command" \ + 'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"' + fi + + # See the names of the shared library. + set dummy $library_names; shift + if test -n "$1"; then + realname="$1" + shift + + srcname="$realname" + test -n "$relink_command" && srcname="$realname"T + + # Install the shared library and build the symlinks. + func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \ + 'exit $?' + tstripme="$stripme" + case $host_os in + cygwin* | mingw* | pw32* | cegcc*) + case $realname in + *.dll.a) + tstripme="" + ;; + esac + ;; + esac + if test -n "$tstripme" && test -n "$striplib"; then + func_show_eval "$striplib $destdir/$realname" 'exit $?' + fi + + if test "$#" -gt 0; then + # Delete the old symlinks, and create new ones. + # Try `ln -sf' first, because the `ln' binary might depend on + # the symlink we replace! Solaris /bin/ln does not understand -f, + # so we also need to try rm && ln -s. + for linkname + do + test "$linkname" != "$realname" \ + && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })" + done + fi + + # Do each command in the postinstall commands. + lib="$destdir/$realname" + func_execute_cmds "$postinstall_cmds" 'exit $?' + fi + + # Install the pseudo-library for information purposes. + func_basename "$file" + name="$func_basename_result" + instname="$dir/$name"i + func_show_eval "$install_prog $instname $destdir/$name" 'exit $?' + + # Maybe install the static library, too. + test -n "$old_library" && func_append staticlibs " $dir/$old_library" + ;; + + *.lo) + # Install (i.e. copy) a libtool object. + + # Figure out destination file name, if it wasn't already specified. + if test -n "$destname"; then + destfile="$destdir/$destname" + else + func_basename "$file" + destfile="$func_basename_result" + destfile="$destdir/$destfile" + fi + + # Deduce the name of the destination old-style object file. + case $destfile in + *.lo) + func_lo2o "$destfile" + staticdest=$func_lo2o_result + ;; + *.$objext) + staticdest="$destfile" + destfile= + ;; + *) + func_fatal_help "cannot copy a libtool object to \`$destfile'" + ;; + esac + + # Install the libtool object if requested. + test -n "$destfile" && \ + func_show_eval "$install_prog $file $destfile" 'exit $?' + + # Install the old object if enabled. + if test "$build_old_libs" = yes; then + # Deduce the name of the old-style object file. + func_lo2o "$file" + staticobj=$func_lo2o_result + func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?' + fi + exit $EXIT_SUCCESS + ;; + + *) + # Figure out destination file name, if it wasn't already specified. + if test -n "$destname"; then + destfile="$destdir/$destname" + else + func_basename "$file" + destfile="$func_basename_result" + destfile="$destdir/$destfile" + fi + + # If the file is missing, and there is a .exe on the end, strip it + # because it is most likely a libtool script we actually want to + # install + stripped_ext="" + case $file in + *.exe) + if test ! -f "$file"; then + func_stripname '' '.exe' "$file" + file=$func_stripname_result + stripped_ext=".exe" + fi + ;; + esac + + # Do a test to see if this is really a libtool program. + case $host in + *cygwin* | *mingw*) + if func_ltwrapper_executable_p "$file"; then + func_ltwrapper_scriptname "$file" + wrapper=$func_ltwrapper_scriptname_result + else + func_stripname '' '.exe' "$file" + wrapper=$func_stripname_result + fi + ;; + *) + wrapper=$file + ;; + esac + if func_ltwrapper_script_p "$wrapper"; then + notinst_deplibs= + relink_command= + + func_source "$wrapper" + + # Check the variables that should have been set. + test -z "$generated_by_libtool_version" && \ + func_fatal_error "invalid libtool wrapper script \`$wrapper'" + + finalize=yes + for lib in $notinst_deplibs; do + # Check to see that each library is installed. + libdir= + if test -f "$lib"; then + func_source "$lib" + fi + libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test + if test -n "$libdir" && test ! -f "$libfile"; then + func_warning "\`$lib' has not been installed in \`$libdir'" + finalize=no + fi + done + + relink_command= + func_source "$wrapper" + + outputname= + if test "$fast_install" = no && test -n "$relink_command"; then + $opt_dry_run || { + if test "$finalize" = yes; then + tmpdir=`func_mktempdir` + func_basename "$file$stripped_ext" + file="$func_basename_result" + outputname="$tmpdir/$file" + # Replace the output file specification. + relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'` + + $opt_silent || { + func_quote_for_expand "$relink_command" + eval "func_echo $func_quote_for_expand_result" + } + if eval "$relink_command"; then : + else + func_error "error: relink \`$file' with the above command before installing it" + $opt_dry_run || ${RM}r "$tmpdir" + continue + fi + file="$outputname" + else + func_warning "cannot relink \`$file'" + fi + } + else + # Install the binary that we compiled earlier. + file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"` + fi + fi + + # remove .exe since cygwin /usr/bin/install will append another + # one anyway + case $install_prog,$host in + */usr/bin/install*,*cygwin*) + case $file:$destfile in + *.exe:*.exe) + # this is ok + ;; + *.exe:*) + destfile=$destfile.exe + ;; + *:*.exe) + func_stripname '' '.exe' "$destfile" + destfile=$func_stripname_result + ;; + esac + ;; + esac + func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?' + $opt_dry_run || if test -n "$outputname"; then + ${RM}r "$tmpdir" + fi + ;; + esac + done + + for file in $staticlibs; do + func_basename "$file" + name="$func_basename_result" + + # Set up the ranlib parameters. + oldlib="$destdir/$name" + func_to_tool_file "$oldlib" func_convert_file_msys_to_w32 + tool_oldlib=$func_to_tool_file_result + + func_show_eval "$install_prog \$file \$oldlib" 'exit $?' + + if test -n "$stripme" && test -n "$old_striplib"; then + func_show_eval "$old_striplib $tool_oldlib" 'exit $?' + fi + + # Do each command in the postinstall commands. + func_execute_cmds "$old_postinstall_cmds" 'exit $?' + done + + test -n "$future_libdirs" && \ + func_warning "remember to run \`$progname --finish$future_libdirs'" + + if test -n "$current_libdirs"; then + # Maybe just do a dry run. + $opt_dry_run && current_libdirs=" -n$current_libdirs" + exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs' + else + exit $EXIT_SUCCESS + fi +} + +test "$opt_mode" = install && func_mode_install ${1+"$@"} + + +# func_generate_dlsyms outputname originator pic_p +# Extract symbols from dlprefiles and create ${outputname}S.o with +# a dlpreopen symbol table. +func_generate_dlsyms () +{ + $opt_debug + my_outputname="$1" + my_originator="$2" + my_pic_p="${3-no}" + my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'` + my_dlsyms= + + if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then + if test -n "$NM" && test -n "$global_symbol_pipe"; then + my_dlsyms="${my_outputname}S.c" + else + func_error "not configured to extract global symbols from dlpreopened files" + fi + fi + + if test -n "$my_dlsyms"; then + case $my_dlsyms in + "") ;; + *.c) + # Discover the nlist of each of the dlfiles. + nlist="$output_objdir/${my_outputname}.nm" + + func_show_eval "$RM $nlist ${nlist}S ${nlist}T" + + # Parse the name list into a source file. + func_verbose "creating $output_objdir/$my_dlsyms" + + $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\ +/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */ +/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */ + +#ifdef __cplusplus +extern \"C\" { +#endif + +#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4)) +#pragma GCC diagnostic ignored \"-Wstrict-prototypes\" +#endif + +/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */ +#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE) +/* DATA imports from DLLs on WIN32 con't be const, because runtime + relocations are performed -- see ld's documentation on pseudo-relocs. */ +# define LT_DLSYM_CONST +#elif defined(__osf__) +/* This system does not cope well with relocations in const data. */ +# define LT_DLSYM_CONST +#else +# define LT_DLSYM_CONST const +#endif + +/* External symbol declarations for the compiler. */\ +" + + if test "$dlself" = yes; then + func_verbose "generating symbol list for \`$output'" + + $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist" + + # Add our own program objects to the symbol list. + progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP` + for progfile in $progfiles; do + func_to_tool_file "$progfile" func_convert_file_msys_to_w32 + func_verbose "extracting global C symbols from \`$func_to_tool_file_result'" + $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'" + done + + if test -n "$exclude_expsyms"; then + $opt_dry_run || { + eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T' + eval '$MV "$nlist"T "$nlist"' + } + fi + + if test -n "$export_symbols_regex"; then + $opt_dry_run || { + eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T' + eval '$MV "$nlist"T "$nlist"' + } + fi + + # Prepare the list of exported symbols + if test -z "$export_symbols"; then + export_symbols="$output_objdir/$outputname.exp" + $opt_dry_run || { + $RM $export_symbols + eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"' + case $host in + *cygwin* | *mingw* | *cegcc* ) + eval "echo EXPORTS "'> "$output_objdir/$outputname.def"' + eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"' + ;; + esac + } + else + $opt_dry_run || { + eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"' + eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T' + eval '$MV "$nlist"T "$nlist"' + case $host in + *cygwin* | *mingw* | *cegcc* ) + eval "echo EXPORTS "'> "$output_objdir/$outputname.def"' + eval 'cat "$nlist" >> "$output_objdir/$outputname.def"' + ;; + esac + } + fi + fi + + for dlprefile in $dlprefiles; do + func_verbose "extracting global C symbols from \`$dlprefile'" + func_basename "$dlprefile" + name="$func_basename_result" + case $host in + *cygwin* | *mingw* | *cegcc* ) + # if an import library, we need to obtain dlname + if func_win32_import_lib_p "$dlprefile"; then + func_tr_sh "$dlprefile" + eval "curr_lafile=\$libfile_$func_tr_sh_result" + dlprefile_dlbasename="" + if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then + # Use subshell, to avoid clobbering current variable values + dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"` + if test -n "$dlprefile_dlname" ; then + func_basename "$dlprefile_dlname" + dlprefile_dlbasename="$func_basename_result" + else + # no lafile. user explicitly requested -dlpreopen . + $sharedlib_from_linklib_cmd "$dlprefile" + dlprefile_dlbasename=$sharedlib_from_linklib_result + fi + fi + $opt_dry_run || { + if test -n "$dlprefile_dlbasename" ; then + eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"' + else + func_warning "Could not compute DLL name from $name" + eval '$ECHO ": $name " >> "$nlist"' + fi + func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32 + eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe | + $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'" + } + else # not an import lib + $opt_dry_run || { + eval '$ECHO ": $name " >> "$nlist"' + func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32 + eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'" + } + fi + ;; + *) + $opt_dry_run || { + eval '$ECHO ": $name " >> "$nlist"' + func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32 + eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'" + } + ;; + esac + done + + $opt_dry_run || { + # Make sure we have at least an empty file. + test -f "$nlist" || : > "$nlist" + + if test -n "$exclude_expsyms"; then + $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T + $MV "$nlist"T "$nlist" + fi + + # Try sorting and uniquifying the output. + if $GREP -v "^: " < "$nlist" | + if sort -k 3 /dev/null 2>&1; then + sort -k 3 + else + sort +2 + fi | + uniq > "$nlist"S; then + : + else + $GREP -v "^: " < "$nlist" > "$nlist"S + fi + + if test -f "$nlist"S; then + eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"' + else + echo '/* NONE */' >> "$output_objdir/$my_dlsyms" + fi + + echo >> "$output_objdir/$my_dlsyms" "\ + +/* The mapping between symbol names and symbols. */ +typedef struct { + const char *name; + void *address; +} lt_dlsymlist; +extern LT_DLSYM_CONST lt_dlsymlist +lt_${my_prefix}_LTX_preloaded_symbols[]; +LT_DLSYM_CONST lt_dlsymlist +lt_${my_prefix}_LTX_preloaded_symbols[] = +{\ + { \"$my_originator\", (void *) 0 }," + + case $need_lib_prefix in + no) + eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms" + ;; + *) + eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms" + ;; + esac + echo >> "$output_objdir/$my_dlsyms" "\ + {0, (void *) 0} +}; + +/* This works around a problem in FreeBSD linker */ +#ifdef FREEBSD_WORKAROUND +static const void *lt_preloaded_setup() { + return lt_${my_prefix}_LTX_preloaded_symbols; +} +#endif + +#ifdef __cplusplus +} +#endif\ +" + } # !$opt_dry_run + + pic_flag_for_symtable= + case "$compile_command " in + *" -static "*) ;; + *) + case $host in + # compiling the symbol table file with pic_flag works around + # a FreeBSD bug that causes programs to crash when -lm is + # linked before any other PIC object. But we must not use + # pic_flag when linking with -static. The problem exists in + # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1. + *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*) + pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;; + *-*-hpux*) + pic_flag_for_symtable=" $pic_flag" ;; + *) + if test "X$my_pic_p" != Xno; then + pic_flag_for_symtable=" $pic_flag" + fi + ;; + esac + ;; + esac + symtab_cflags= + for arg in $LTCFLAGS; do + case $arg in + -pie | -fpie | -fPIE) ;; + *) func_append symtab_cflags " $arg" ;; + esac + done + + # Now compile the dynamic symbol file. + func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?' + + # Clean up the generated files. + func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"' + + # Transform the symbol file into the correct name. + symfileobj="$output_objdir/${my_outputname}S.$objext" + case $host in + *cygwin* | *mingw* | *cegcc* ) + if test -f "$output_objdir/$my_outputname.def"; then + compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"` + finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"` + else + compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"` + finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"` + fi + ;; + *) + compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"` + finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"` + ;; + esac + ;; + *) + func_fatal_error "unknown suffix for \`$my_dlsyms'" + ;; + esac + else + # We keep going just in case the user didn't refer to + # lt_preloaded_symbols. The linker will fail if global_symbol_pipe + # really was required. + + # Nullify the symbol file. + compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"` + finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"` + fi +} + +# func_win32_libid arg +# return the library type of file 'arg' +# +# Need a lot of goo to handle *both* DLLs and import libs +# Has to be a shell function in order to 'eat' the argument +# that is supplied when $file_magic_command is called. +# Despite the name, also deal with 64 bit binaries. +func_win32_libid () +{ + $opt_debug + win32_libid_type="unknown" + win32_fileres=`file -L $1 2>/dev/null` + case $win32_fileres in + *ar\ archive\ import\ library*) # definitely import + win32_libid_type="x86 archive import" + ;; + *ar\ archive*) # could be an import, or static + # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD. + if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | + $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then + func_to_tool_file "$1" func_convert_file_msys_to_w32 + win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" | + $SED -n -e ' + 1,100{ + / I /{ + s,.*,import, + p + q + } + }'` + case $win32_nmres in + import*) win32_libid_type="x86 archive import";; + *) win32_libid_type="x86 archive static";; + esac + fi + ;; + *DLL*) + win32_libid_type="x86 DLL" + ;; + *executable*) # but shell scripts are "executable" too... + case $win32_fileres in + *MS\ Windows\ PE\ Intel*) + win32_libid_type="x86 DLL" + ;; + esac + ;; + esac + $ECHO "$win32_libid_type" +} + +# func_cygming_dll_for_implib ARG +# +# Platform-specific function to extract the +# name of the DLL associated with the specified +# import library ARG. +# Invoked by eval'ing the libtool variable +# $sharedlib_from_linklib_cmd +# Result is available in the variable +# $sharedlib_from_linklib_result +func_cygming_dll_for_implib () +{ + $opt_debug + sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"` +} + +# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs +# +# The is the core of a fallback implementation of a +# platform-specific function to extract the name of the +# DLL associated with the specified import library LIBNAME. +# +# SECTION_NAME is either .idata$6 or .idata$7, depending +# on the platform and compiler that created the implib. +# +# Echos the name of the DLL associated with the +# specified import library. +func_cygming_dll_for_implib_fallback_core () +{ + $opt_debug + match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"` + $OBJDUMP -s --section "$1" "$2" 2>/dev/null | + $SED '/^Contents of section '"$match_literal"':/{ + # Place marker at beginning of archive member dllname section + s/.*/====MARK====/ + p + d + } + # These lines can sometimes be longer than 43 characters, but + # are always uninteresting + /:[ ]*file format pe[i]\{,1\}-/d + /^In archive [^:]*:/d + # Ensure marker is printed + /^====MARK====/p + # Remove all lines with less than 43 characters + /^.\{43\}/!d + # From remaining lines, remove first 43 characters + s/^.\{43\}//' | + $SED -n ' + # Join marker and all lines until next marker into a single line + /^====MARK====/ b para + H + $ b para + b + :para + x + s/\n//g + # Remove the marker + s/^====MARK====// + # Remove trailing dots and whitespace + s/[\. \t]*$// + # Print + /./p' | + # we now have a list, one entry per line, of the stringified + # contents of the appropriate section of all members of the + # archive which possess that section. Heuristic: eliminate + # all those which have a first or second character that is + # a '.' (that is, objdump's representation of an unprintable + # character.) This should work for all archives with less than + # 0x302f exports -- but will fail for DLLs whose name actually + # begins with a literal '.' or a single character followed by + # a '.'. + # + # Of those that remain, print the first one. + $SED -e '/^\./d;/^.\./d;q' +} + +# func_cygming_gnu_implib_p ARG +# This predicate returns with zero status (TRUE) if +# ARG is a GNU/binutils-style import library. Returns +# with nonzero status (FALSE) otherwise. +func_cygming_gnu_implib_p () +{ + $opt_debug + func_to_tool_file "$1" func_convert_file_msys_to_w32 + func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'` + test -n "$func_cygming_gnu_implib_tmp" +} + +# func_cygming_ms_implib_p ARG +# This predicate returns with zero status (TRUE) if +# ARG is an MS-style import library. Returns +# with nonzero status (FALSE) otherwise. +func_cygming_ms_implib_p () +{ + $opt_debug + func_to_tool_file "$1" func_convert_file_msys_to_w32 + func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'` + test -n "$func_cygming_ms_implib_tmp" +} + +# func_cygming_dll_for_implib_fallback ARG +# Platform-specific function to extract the +# name of the DLL associated with the specified +# import library ARG. +# +# This fallback implementation is for use when $DLLTOOL +# does not support the --identify-strict option. +# Invoked by eval'ing the libtool variable +# $sharedlib_from_linklib_cmd +# Result is available in the variable +# $sharedlib_from_linklib_result +func_cygming_dll_for_implib_fallback () +{ + $opt_debug + if func_cygming_gnu_implib_p "$1" ; then + # binutils import library + sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"` + elif func_cygming_ms_implib_p "$1" ; then + # ms-generated import library + sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"` + else + # unknown + sharedlib_from_linklib_result="" + fi +} + + +# func_extract_an_archive dir oldlib +func_extract_an_archive () +{ + $opt_debug + f_ex_an_ar_dir="$1"; shift + f_ex_an_ar_oldlib="$1" + if test "$lock_old_archive_extraction" = yes; then + lockfile=$f_ex_an_ar_oldlib.lock + until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do + func_echo "Waiting for $lockfile to be removed" + sleep 2 + done + fi + func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \ + 'stat=$?; rm -f "$lockfile"; exit $stat' + if test "$lock_old_archive_extraction" = yes; then + $opt_dry_run || rm -f "$lockfile" + fi + if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then + : + else + func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" + fi +} + + +# func_extract_archives gentop oldlib ... +func_extract_archives () +{ + $opt_debug + my_gentop="$1"; shift + my_oldlibs=${1+"$@"} + my_oldobjs="" + my_xlib="" + my_xabs="" + my_xdir="" + + for my_xlib in $my_oldlibs; do + # Extract the objects. + case $my_xlib in + [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;; + *) my_xabs=`pwd`"/$my_xlib" ;; + esac + func_basename "$my_xlib" + my_xlib="$func_basename_result" + my_xlib_u=$my_xlib + while :; do + case " $extracted_archives " in + *" $my_xlib_u "*) + func_arith $extracted_serial + 1 + extracted_serial=$func_arith_result + my_xlib_u=lt$extracted_serial-$my_xlib ;; + *) break ;; + esac + done + extracted_archives="$extracted_archives $my_xlib_u" + my_xdir="$my_gentop/$my_xlib_u" + + func_mkdir_p "$my_xdir" + + case $host in + *-darwin*) + func_verbose "Extracting $my_xabs" + # Do not bother doing anything if just a dry run + $opt_dry_run || { + darwin_orig_dir=`pwd` + cd $my_xdir || exit $? + darwin_archive=$my_xabs + darwin_curdir=`pwd` + darwin_base_archive=`basename "$darwin_archive"` + darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true` + if test -n "$darwin_arches"; then + darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'` + darwin_arch= + func_verbose "$darwin_base_archive has multiple architectures $darwin_arches" + for darwin_arch in $darwin_arches ; do + func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}" + $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}" + cd "unfat-$$/${darwin_base_archive}-${darwin_arch}" + func_extract_an_archive "`pwd`" "${darwin_base_archive}" + cd "$darwin_curdir" + $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" + done # $darwin_arches + ## Okay now we've a bunch of thin objects, gotta fatten them up :) + darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u` + darwin_file= + darwin_files= + for darwin_file in $darwin_filelist; do + darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP` + $LIPO -create -output "$darwin_file" $darwin_files + done # $darwin_filelist + $RM -rf unfat-$$ + cd "$darwin_orig_dir" + else + cd $darwin_orig_dir + func_extract_an_archive "$my_xdir" "$my_xabs" + fi # $darwin_arches + } # !$opt_dry_run + ;; + *) + func_extract_an_archive "$my_xdir" "$my_xabs" + ;; + esac + my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP` + done + + func_extract_archives_result="$my_oldobjs" +} + + +# func_emit_wrapper [arg=no] +# +# Emit a libtool wrapper script on stdout. +# Don't directly open a file because we may want to +# incorporate the script contents within a cygwin/mingw +# wrapper executable. Must ONLY be called from within +# func_mode_link because it depends on a number of variables +# set therein. +# +# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR +# variable will take. If 'yes', then the emitted script +# will assume that the directory in which it is stored is +# the $objdir directory. This is a cygwin/mingw-specific +# behavior. +func_emit_wrapper () +{ + func_emit_wrapper_arg1=${1-no} + + $ECHO "\ +#! $SHELL + +# $output - temporary wrapper script for $objdir/$outputname +# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION +# +# The $output program cannot be directly executed until all the libtool +# libraries that it depends on are installed. +# +# This wrapper script should never be moved out of the build directory. +# If it is, it will not operate correctly. + +# Sed substitution that helps us do robust quoting. It backslashifies +# metacharacters that are still active within double-quoted strings. +sed_quote_subst='$sed_quote_subst' + +# Be Bourne compatible +if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then + emulate sh + NULLCMD=: + # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which + # is contrary to our usage. Disable this feature. + alias -g '\${1+\"\$@\"}'='\"\$@\"' + setopt NO_GLOB_SUBST +else + case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac +fi +BIN_SH=xpg4; export BIN_SH # for Tru64 +DUALCASE=1; export DUALCASE # for MKS sh + +# The HP-UX ksh and POSIX shell print the target directory to stdout +# if CDPATH is set. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + +relink_command=\"$relink_command\" + +# This environment variable determines our operation mode. +if test \"\$libtool_install_magic\" = \"$magic\"; then + # install mode needs the following variables: + generated_by_libtool_version='$macro_version' + notinst_deplibs='$notinst_deplibs' +else + # When we are sourced in execute mode, \$file and \$ECHO are already set. + if test \"\$libtool_execute_magic\" != \"$magic\"; then + file=\"\$0\"" + + qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"` + $ECHO "\ + +# A function that is used when there is no print builtin or printf. +func_fallback_echo () +{ + eval 'cat <<_LTECHO_EOF +\$1 +_LTECHO_EOF' +} + ECHO=\"$qECHO\" + fi + +# Very basic option parsing. These options are (a) specific to +# the libtool wrapper, (b) are identical between the wrapper +# /script/ and the wrapper /executable/ which is used only on +# windows platforms, and (c) all begin with the string "--lt-" +# (application programs are unlikely to have options which match +# this pattern). +# +# There are only two supported options: --lt-debug and +# --lt-dump-script. There is, deliberately, no --lt-help. +# +# The first argument to this parsing function should be the +# script's $0 value, followed by "$@". +lt_option_debug= +func_parse_lt_options () +{ + lt_script_arg0=\$0 + shift + for lt_opt + do + case \"\$lt_opt\" in + --lt-debug) lt_option_debug=1 ;; + --lt-dump-script) + lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\` + test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=. + lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\` + cat \"\$lt_dump_D/\$lt_dump_F\" + exit 0 + ;; + --lt-*) + \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2 + exit 1 + ;; + esac + done + + # Print the debug banner immediately: + if test -n \"\$lt_option_debug\"; then + echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2 + fi +} + +# Used when --lt-debug. Prints its arguments to stdout +# (redirection is the responsibility of the caller) +func_lt_dump_args () +{ + lt_dump_args_N=1; + for lt_arg + do + \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\" + lt_dump_args_N=\`expr \$lt_dump_args_N + 1\` + done +} + +# Core function for launching the target application +func_exec_program_core () +{ +" + case $host in + # Backslashes separate directories on plain windows + *-*-mingw | *-*-os2* | *-cegcc*) + $ECHO "\ + if test -n \"\$lt_option_debug\"; then + \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2 + func_lt_dump_args \${1+\"\$@\"} 1>&2 + fi + exec \"\$progdir\\\\\$program\" \${1+\"\$@\"} +" + ;; + + *) + $ECHO "\ + if test -n \"\$lt_option_debug\"; then + \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2 + func_lt_dump_args \${1+\"\$@\"} 1>&2 + fi + exec \"\$progdir/\$program\" \${1+\"\$@\"} +" + ;; + esac + $ECHO "\ + \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2 + exit 1 +} + +# A function to encapsulate launching the target application +# Strips options in the --lt-* namespace from \$@ and +# launches target application with the remaining arguments. +func_exec_program () +{ + case \" \$* \" in + *\\ --lt-*) + for lt_wr_arg + do + case \$lt_wr_arg in + --lt-*) ;; + *) set x \"\$@\" \"\$lt_wr_arg\"; shift;; + esac + shift + done ;; + esac + func_exec_program_core \${1+\"\$@\"} +} + + # Parse options + func_parse_lt_options \"\$0\" \${1+\"\$@\"} + + # Find the directory that this script lives in. + thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\` + test \"x\$thisdir\" = \"x\$file\" && thisdir=. + + # Follow symbolic links until we get to the real thisdir. + file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\` + while test -n \"\$file\"; do + destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\` + + # If there was a directory component, then change thisdir. + if test \"x\$destdir\" != \"x\$file\"; then + case \"\$destdir\" in + [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;; + *) thisdir=\"\$thisdir/\$destdir\" ;; + esac + fi + + file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\` + file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\` + done + + # Usually 'no', except on cygwin/mingw when embedded into + # the cwrapper. + WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1 + if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then + # special case for '.' + if test \"\$thisdir\" = \".\"; then + thisdir=\`pwd\` + fi + # remove .libs from thisdir + case \"\$thisdir\" in + *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;; + $objdir ) thisdir=. ;; + esac + fi + + # Try to get the absolute directory name. + absdir=\`cd \"\$thisdir\" && pwd\` + test -n \"\$absdir\" && thisdir=\"\$absdir\" +" + + if test "$fast_install" = yes; then + $ECHO "\ + program=lt-'$outputname'$exeext + progdir=\"\$thisdir/$objdir\" + + if test ! -f \"\$progdir/\$program\" || + { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\ + test \"X\$file\" != \"X\$progdir/\$program\"; }; then + + file=\"\$\$-\$program\" + + if test ! -d \"\$progdir\"; then + $MKDIR \"\$progdir\" + else + $RM \"\$progdir/\$file\" + fi" + + $ECHO "\ + + # relink executable if necessary + if test -n \"\$relink_command\"; then + if relink_command_output=\`eval \$relink_command 2>&1\`; then : + else + $ECHO \"\$relink_command_output\" >&2 + $RM \"\$progdir/\$file\" + exit 1 + fi + fi + + $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null || + { $RM \"\$progdir/\$program\"; + $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; } + $RM \"\$progdir/\$file\" + fi" + else + $ECHO "\ + program='$outputname' + progdir=\"\$thisdir/$objdir\" +" + fi + + $ECHO "\ + + if test -f \"\$progdir/\$program\"; then" + + # fixup the dll searchpath if we need to. + # + # Fix the DLL searchpath if we need to. Do this before prepending + # to shlibpath, because on Windows, both are PATH and uninstalled + # libraries must come first. + if test -n "$dllsearchpath"; then + $ECHO "\ + # Add the dll search path components to the executable PATH + PATH=$dllsearchpath:\$PATH +" + fi + + # Export our shlibpath_var if we have one. + if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then + $ECHO "\ + # Add our own library path to $shlibpath_var + $shlibpath_var=\"$temp_rpath\$$shlibpath_var\" + + # Some systems cannot cope with colon-terminated $shlibpath_var + # The second colon is a workaround for a bug in BeOS R4 sed + $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\` + + export $shlibpath_var +" + fi + + $ECHO "\ + if test \"\$libtool_execute_magic\" != \"$magic\"; then + # Run the actual program with our arguments. + func_exec_program \${1+\"\$@\"} + fi + else + # The program doesn't exist. + \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2 + \$ECHO \"This script is just a wrapper for \$program.\" 1>&2 + \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2 + exit 1 + fi +fi\ +" +} + + +# func_emit_cwrapperexe_src +# emit the source code for a wrapper executable on stdout +# Must ONLY be called from within func_mode_link because +# it depends on a number of variable set therein. +func_emit_cwrapperexe_src () +{ + cat < +#include +#ifdef _MSC_VER +# include +# include +# include +#else +# include +# include +# ifdef __CYGWIN__ +# include +# endif +#endif +#include +#include +#include +#include +#include +#include +#include +#include + +/* declarations of non-ANSI functions */ +#if defined(__MINGW32__) +# ifdef __STRICT_ANSI__ +int _putenv (const char *); +# endif +#elif defined(__CYGWIN__) +# ifdef __STRICT_ANSI__ +char *realpath (const char *, char *); +int putenv (char *); +int setenv (const char *, const char *, int); +# endif +/* #elif defined (other platforms) ... */ +#endif + +/* portability defines, excluding path handling macros */ +#if defined(_MSC_VER) +# define setmode _setmode +# define stat _stat +# define chmod _chmod +# define getcwd _getcwd +# define putenv _putenv +# define S_IXUSR _S_IEXEC +# ifndef _INTPTR_T_DEFINED +# define _INTPTR_T_DEFINED +# define intptr_t int +# endif +#elif defined(__MINGW32__) +# define setmode _setmode +# define stat _stat +# define chmod _chmod +# define getcwd _getcwd +# define putenv _putenv +#elif defined(__CYGWIN__) +# define HAVE_SETENV +# define FOPEN_WB "wb" +/* #elif defined (other platforms) ... */ +#endif + +#if defined(PATH_MAX) +# define LT_PATHMAX PATH_MAX +#elif defined(MAXPATHLEN) +# define LT_PATHMAX MAXPATHLEN +#else +# define LT_PATHMAX 1024 +#endif + +#ifndef S_IXOTH +# define S_IXOTH 0 +#endif +#ifndef S_IXGRP +# define S_IXGRP 0 +#endif + +/* path handling portability macros */ +#ifndef DIR_SEPARATOR +# define DIR_SEPARATOR '/' +# define PATH_SEPARATOR ':' +#endif + +#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \ + defined (__OS2__) +# define HAVE_DOS_BASED_FILE_SYSTEM +# define FOPEN_WB "wb" +# ifndef DIR_SEPARATOR_2 +# define DIR_SEPARATOR_2 '\\' +# endif +# ifndef PATH_SEPARATOR_2 +# define PATH_SEPARATOR_2 ';' +# endif +#endif + +#ifndef DIR_SEPARATOR_2 +# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR) +#else /* DIR_SEPARATOR_2 */ +# define IS_DIR_SEPARATOR(ch) \ + (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2)) +#endif /* DIR_SEPARATOR_2 */ + +#ifndef PATH_SEPARATOR_2 +# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR) +#else /* PATH_SEPARATOR_2 */ +# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2) +#endif /* PATH_SEPARATOR_2 */ + +#ifndef FOPEN_WB +# define FOPEN_WB "w" +#endif +#ifndef _O_BINARY +# define _O_BINARY 0 +#endif + +#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type))) +#define XFREE(stale) do { \ + if (stale) { free ((void *) stale); stale = 0; } \ +} while (0) + +#if defined(LT_DEBUGWRAPPER) +static int lt_debug = 1; +#else +static int lt_debug = 0; +#endif + +const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */ + +void *xmalloc (size_t num); +char *xstrdup (const char *string); +const char *base_name (const char *name); +char *find_executable (const char *wrapper); +char *chase_symlinks (const char *pathspec); +int make_executable (const char *path); +int check_executable (const char *path); +char *strendzap (char *str, const char *pat); +void lt_debugprintf (const char *file, int line, const char *fmt, ...); +void lt_fatal (const char *file, int line, const char *message, ...); +static const char *nonnull (const char *s); +static const char *nonempty (const char *s); +void lt_setenv (const char *name, const char *value); +char *lt_extend_str (const char *orig_value, const char *add, int to_end); +void lt_update_exe_path (const char *name, const char *value); +void lt_update_lib_path (const char *name, const char *value); +char **prepare_spawn (char **argv); +void lt_dump_script (FILE *f); +EOF + + cat <= 0) + && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) + return 1; + else + return 0; +} + +int +make_executable (const char *path) +{ + int rval = 0; + struct stat st; + + lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n", + nonempty (path)); + if ((!path) || (!*path)) + return 0; + + if (stat (path, &st) >= 0) + { + rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR); + } + return rval; +} + +/* Searches for the full path of the wrapper. Returns + newly allocated full path name if found, NULL otherwise + Does not chase symlinks, even on platforms that support them. +*/ +char * +find_executable (const char *wrapper) +{ + int has_slash = 0; + const char *p; + const char *p_next; + /* static buffer for getcwd */ + char tmp[LT_PATHMAX + 1]; + int tmp_len; + char *concat_name; + + lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n", + nonempty (wrapper)); + + if ((wrapper == NULL) || (*wrapper == '\0')) + return NULL; + + /* Absolute path? */ +#if defined (HAVE_DOS_BASED_FILE_SYSTEM) + if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':') + { + concat_name = xstrdup (wrapper); + if (check_executable (concat_name)) + return concat_name; + XFREE (concat_name); + } + else + { +#endif + if (IS_DIR_SEPARATOR (wrapper[0])) + { + concat_name = xstrdup (wrapper); + if (check_executable (concat_name)) + return concat_name; + XFREE (concat_name); + } +#if defined (HAVE_DOS_BASED_FILE_SYSTEM) + } +#endif + + for (p = wrapper; *p; p++) + if (*p == '/') + { + has_slash = 1; + break; + } + if (!has_slash) + { + /* no slashes; search PATH */ + const char *path = getenv ("PATH"); + if (path != NULL) + { + for (p = path; *p; p = p_next) + { + const char *q; + size_t p_len; + for (q = p; *q; q++) + if (IS_PATH_SEPARATOR (*q)) + break; + p_len = q - p; + p_next = (*q == '\0' ? q : q + 1); + if (p_len == 0) + { + /* empty path: current directory */ + if (getcwd (tmp, LT_PATHMAX) == NULL) + lt_fatal (__FILE__, __LINE__, "getcwd failed: %s", + nonnull (strerror (errno))); + tmp_len = strlen (tmp); + concat_name = + XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1); + memcpy (concat_name, tmp, tmp_len); + concat_name[tmp_len] = '/'; + strcpy (concat_name + tmp_len + 1, wrapper); + } + else + { + concat_name = + XMALLOC (char, p_len + 1 + strlen (wrapper) + 1); + memcpy (concat_name, p, p_len); + concat_name[p_len] = '/'; + strcpy (concat_name + p_len + 1, wrapper); + } + if (check_executable (concat_name)) + return concat_name; + XFREE (concat_name); + } + } + /* not found in PATH; assume curdir */ + } + /* Relative path | not found in path: prepend cwd */ + if (getcwd (tmp, LT_PATHMAX) == NULL) + lt_fatal (__FILE__, __LINE__, "getcwd failed: %s", + nonnull (strerror (errno))); + tmp_len = strlen (tmp); + concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1); + memcpy (concat_name, tmp, tmp_len); + concat_name[tmp_len] = '/'; + strcpy (concat_name + tmp_len + 1, wrapper); + + if (check_executable (concat_name)) + return concat_name; + XFREE (concat_name); + return NULL; +} + +char * +chase_symlinks (const char *pathspec) +{ +#ifndef S_ISLNK + return xstrdup (pathspec); +#else + char buf[LT_PATHMAX]; + struct stat s; + char *tmp_pathspec = xstrdup (pathspec); + char *p; + int has_symlinks = 0; + while (strlen (tmp_pathspec) && !has_symlinks) + { + lt_debugprintf (__FILE__, __LINE__, + "checking path component for symlinks: %s\n", + tmp_pathspec); + if (lstat (tmp_pathspec, &s) == 0) + { + if (S_ISLNK (s.st_mode) != 0) + { + has_symlinks = 1; + break; + } + + /* search backwards for last DIR_SEPARATOR */ + p = tmp_pathspec + strlen (tmp_pathspec) - 1; + while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p))) + p--; + if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p))) + { + /* no more DIR_SEPARATORS left */ + break; + } + *p = '\0'; + } + else + { + lt_fatal (__FILE__, __LINE__, + "error accessing file \"%s\": %s", + tmp_pathspec, nonnull (strerror (errno))); + } + } + XFREE (tmp_pathspec); + + if (!has_symlinks) + { + return xstrdup (pathspec); + } + + tmp_pathspec = realpath (pathspec, buf); + if (tmp_pathspec == 0) + { + lt_fatal (__FILE__, __LINE__, + "could not follow symlinks for %s", pathspec); + } + return xstrdup (tmp_pathspec); +#endif +} + +char * +strendzap (char *str, const char *pat) +{ + size_t len, patlen; + + assert (str != NULL); + assert (pat != NULL); + + len = strlen (str); + patlen = strlen (pat); + + if (patlen <= len) + { + str += len - patlen; + if (strcmp (str, pat) == 0) + *str = '\0'; + } + return str; +} + +void +lt_debugprintf (const char *file, int line, const char *fmt, ...) +{ + va_list args; + if (lt_debug) + { + (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line); + va_start (args, fmt); + (void) vfprintf (stderr, fmt, args); + va_end (args); + } +} + +static void +lt_error_core (int exit_status, const char *file, + int line, const char *mode, + const char *message, va_list ap) +{ + fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode); + vfprintf (stderr, message, ap); + fprintf (stderr, ".\n"); + + if (exit_status >= 0) + exit (exit_status); +} + +void +lt_fatal (const char *file, int line, const char *message, ...) +{ + va_list ap; + va_start (ap, message); + lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap); + va_end (ap); +} + +static const char * +nonnull (const char *s) +{ + return s ? s : "(null)"; +} + +static const char * +nonempty (const char *s) +{ + return (s && !*s) ? "(empty)" : nonnull (s); +} + +void +lt_setenv (const char *name, const char *value) +{ + lt_debugprintf (__FILE__, __LINE__, + "(lt_setenv) setting '%s' to '%s'\n", + nonnull (name), nonnull (value)); + { +#ifdef HAVE_SETENV + /* always make a copy, for consistency with !HAVE_SETENV */ + char *str = xstrdup (value); + setenv (name, str, 1); +#else + int len = strlen (name) + 1 + strlen (value) + 1; + char *str = XMALLOC (char, len); + sprintf (str, "%s=%s", name, value); + if (putenv (str) != EXIT_SUCCESS) + { + XFREE (str); + } +#endif + } +} + +char * +lt_extend_str (const char *orig_value, const char *add, int to_end) +{ + char *new_value; + if (orig_value && *orig_value) + { + int orig_value_len = strlen (orig_value); + int add_len = strlen (add); + new_value = XMALLOC (char, add_len + orig_value_len + 1); + if (to_end) + { + strcpy (new_value, orig_value); + strcpy (new_value + orig_value_len, add); + } + else + { + strcpy (new_value, add); + strcpy (new_value + add_len, orig_value); + } + } + else + { + new_value = xstrdup (add); + } + return new_value; +} + +void +lt_update_exe_path (const char *name, const char *value) +{ + lt_debugprintf (__FILE__, __LINE__, + "(lt_update_exe_path) modifying '%s' by prepending '%s'\n", + nonnull (name), nonnull (value)); + + if (name && *name && value && *value) + { + char *new_value = lt_extend_str (getenv (name), value, 0); + /* some systems can't cope with a ':'-terminated path #' */ + int len = strlen (new_value); + while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1])) + { + new_value[len-1] = '\0'; + } + lt_setenv (name, new_value); + XFREE (new_value); + } +} + +void +lt_update_lib_path (const char *name, const char *value) +{ + lt_debugprintf (__FILE__, __LINE__, + "(lt_update_lib_path) modifying '%s' by prepending '%s'\n", + nonnull (name), nonnull (value)); + + if (name && *name && value && *value) + { + char *new_value = lt_extend_str (getenv (name), value, 0); + lt_setenv (name, new_value); + XFREE (new_value); + } +} + +EOF + case $host_os in + mingw*) + cat <<"EOF" + +/* Prepares an argument vector before calling spawn(). + Note that spawn() does not by itself call the command interpreter + (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") : + ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); + GetVersionEx(&v); + v.dwPlatformId == VER_PLATFORM_WIN32_NT; + }) ? "cmd.exe" : "command.com"). + Instead it simply concatenates the arguments, separated by ' ', and calls + CreateProcess(). We must quote the arguments since Win32 CreateProcess() + interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a + special way: + - Space and tab are interpreted as delimiters. They are not treated as + delimiters if they are surrounded by double quotes: "...". + - Unescaped double quotes are removed from the input. Their only effect is + that within double quotes, space and tab are treated like normal + characters. + - Backslashes not followed by double quotes are not special. + - But 2*n+1 backslashes followed by a double quote become + n backslashes followed by a double quote (n >= 0): + \" -> " + \\\" -> \" + \\\\\" -> \\" + */ +#define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037" +#define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037" +char ** +prepare_spawn (char **argv) +{ + size_t argc; + char **new_argv; + size_t i; + + /* Count number of arguments. */ + for (argc = 0; argv[argc] != NULL; argc++) + ; + + /* Allocate new argument vector. */ + new_argv = XMALLOC (char *, argc + 1); + + /* Put quoted arguments into the new argument vector. */ + for (i = 0; i < argc; i++) + { + const char *string = argv[i]; + + if (string[0] == '\0') + new_argv[i] = xstrdup ("\"\""); + else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL) + { + int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL); + size_t length; + unsigned int backslashes; + const char *s; + char *quoted_string; + char *p; + + length = 0; + backslashes = 0; + if (quote_around) + length++; + for (s = string; *s != '\0'; s++) + { + char c = *s; + if (c == '"') + length += backslashes + 1; + length++; + if (c == '\\') + backslashes++; + else + backslashes = 0; + } + if (quote_around) + length += backslashes + 1; + + quoted_string = XMALLOC (char, length + 1); + + p = quoted_string; + backslashes = 0; + if (quote_around) + *p++ = '"'; + for (s = string; *s != '\0'; s++) + { + char c = *s; + if (c == '"') + { + unsigned int j; + for (j = backslashes + 1; j > 0; j--) + *p++ = '\\'; + } + *p++ = c; + if (c == '\\') + backslashes++; + else + backslashes = 0; + } + if (quote_around) + { + unsigned int j; + for (j = backslashes; j > 0; j--) + *p++ = '\\'; + *p++ = '"'; + } + *p = '\0'; + + new_argv[i] = quoted_string; + } + else + new_argv[i] = (char *) string; + } + new_argv[argc] = NULL; + + return new_argv; +} +EOF + ;; + esac + + cat <<"EOF" +void lt_dump_script (FILE* f) +{ +EOF + func_emit_wrapper yes | + $SED -n -e ' +s/^\(.\{79\}\)\(..*\)/\1\ +\2/ +h +s/\([\\"]\)/\\\1/g +s/$/\\n/ +s/\([^\n]*\).*/ fputs ("\1", f);/p +g +D' + cat <<"EOF" +} +EOF +} +# end: func_emit_cwrapperexe_src + +# func_win32_import_lib_p ARG +# True if ARG is an import lib, as indicated by $file_magic_cmd +func_win32_import_lib_p () +{ + $opt_debug + case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in + *import*) : ;; + *) false ;; + esac +} + +# func_mode_link arg... +func_mode_link () +{ + $opt_debug + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) + # It is impossible to link a dll without this setting, and + # we shouldn't force the makefile maintainer to figure out + # which system we are compiling for in order to pass an extra + # flag for every libtool invocation. + # allow_undefined=no + + # FIXME: Unfortunately, there are problems with the above when trying + # to make a dll which has undefined symbols, in which case not + # even a static library is built. For now, we need to specify + # -no-undefined on the libtool link line when we can be certain + # that all symbols are satisfied, otherwise we get a static library. + allow_undefined=yes + ;; + *) + allow_undefined=yes + ;; + esac + libtool_args=$nonopt + base_compile="$nonopt $@" + compile_command=$nonopt + finalize_command=$nonopt + + compile_rpath= + finalize_rpath= + compile_shlibpath= + finalize_shlibpath= + convenience= + old_convenience= + deplibs= + old_deplibs= + compiler_flags= + linker_flags= + dllsearchpath= + lib_search_path=`pwd` + inst_prefix_dir= + new_inherited_linker_flags= + + avoid_version=no + bindir= + dlfiles= + dlprefiles= + dlself=no + export_dynamic=no + export_symbols= + export_symbols_regex= + generated= + libobjs= + ltlibs= + module=no + no_install=no + objs= + non_pic_objects= + precious_files_regex= + prefer_static_libs=no + preload=no + prev= + prevarg= + release= + rpath= + xrpath= + perm_rpath= + temp_rpath= + thread_safe=no + vinfo= + vinfo_number=no + weak_libs= + single_module="${wl}-single_module" + func_infer_tag $base_compile + + # We need to know -static, to get the right output filenames. + for arg + do + case $arg in + -shared) + test "$build_libtool_libs" != yes && \ + func_fatal_configuration "can not build a shared library" + build_old_libs=no + break + ;; + -all-static | -static | -static-libtool-libs) + case $arg in + -all-static) + if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then + func_warning "complete static linking is impossible in this configuration" + fi + if test -n "$link_static_flag"; then + dlopen_self=$dlopen_self_static + fi + prefer_static_libs=yes + ;; + -static) + if test -z "$pic_flag" && test -n "$link_static_flag"; then + dlopen_self=$dlopen_self_static + fi + prefer_static_libs=built + ;; + -static-libtool-libs) + if test -z "$pic_flag" && test -n "$link_static_flag"; then + dlopen_self=$dlopen_self_static + fi + prefer_static_libs=yes + ;; + esac + build_libtool_libs=no + build_old_libs=yes + break + ;; + esac + done + + # See if our shared archives depend on static archives. + test -n "$old_archive_from_new_cmds" && build_old_libs=yes + + # Go through the arguments, transforming them on the way. + while test "$#" -gt 0; do + arg="$1" + shift + func_quote_for_eval "$arg" + qarg=$func_quote_for_eval_unquoted_result + func_append libtool_args " $func_quote_for_eval_result" + + # If the previous option needs an argument, assign it. + if test -n "$prev"; then + case $prev in + output) + func_append compile_command " @OUTPUT@" + func_append finalize_command " @OUTPUT@" + ;; + esac + + case $prev in + bindir) + bindir="$arg" + prev= + continue + ;; + dlfiles|dlprefiles) + if test "$preload" = no; then + # Add the symbol object into the linking commands. + func_append compile_command " @SYMFILE@" + func_append finalize_command " @SYMFILE@" + preload=yes + fi + case $arg in + *.la | *.lo) ;; # We handle these cases below. + force) + if test "$dlself" = no; then + dlself=needless + export_dynamic=yes + fi + prev= + continue + ;; + self) + if test "$prev" = dlprefiles; then + dlself=yes + elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then + dlself=yes + else + dlself=needless + export_dynamic=yes + fi + prev= + continue + ;; + *) + if test "$prev" = dlfiles; then + func_append dlfiles " $arg" + else + func_append dlprefiles " $arg" + fi + prev= + continue + ;; + esac + ;; + expsyms) + export_symbols="$arg" + test -f "$arg" \ + || func_fatal_error "symbol file \`$arg' does not exist" + prev= + continue + ;; + expsyms_regex) + export_symbols_regex="$arg" + prev= + continue + ;; + framework) + case $host in + *-*-darwin*) + case "$deplibs " in + *" $qarg.ltframework "*) ;; + *) func_append deplibs " $qarg.ltframework" # this is fixed later + ;; + esac + ;; + esac + prev= + continue + ;; + inst_prefix) + inst_prefix_dir="$arg" + prev= + continue + ;; + objectlist) + if test -f "$arg"; then + save_arg=$arg + moreargs= + for fil in `cat "$save_arg"` + do +# func_append moreargs " $fil" + arg=$fil + # A libtool-controlled object. + + # Check to see that this really is a libtool object. + if func_lalib_unsafe_p "$arg"; then + pic_object= + non_pic_object= + + # Read the .lo file + func_source "$arg" + + if test -z "$pic_object" || + test -z "$non_pic_object" || + test "$pic_object" = none && + test "$non_pic_object" = none; then + func_fatal_error "cannot find name of object for \`$arg'" + fi + + # Extract subdirectory from the argument. + func_dirname "$arg" "/" "" + xdir="$func_dirname_result" + + if test "$pic_object" != none; then + # Prepend the subdirectory the object is found in. + pic_object="$xdir$pic_object" + + if test "$prev" = dlfiles; then + if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then + func_append dlfiles " $pic_object" + prev= + continue + else + # If libtool objects are unsupported, then we need to preload. + prev=dlprefiles + fi + fi + + # CHECK ME: I think I busted this. -Ossama + if test "$prev" = dlprefiles; then + # Preload the old-style object. + func_append dlprefiles " $pic_object" + prev= + fi + + # A PIC object. + func_append libobjs " $pic_object" + arg="$pic_object" + fi + + # Non-PIC object. + if test "$non_pic_object" != none; then + # Prepend the subdirectory the object is found in. + non_pic_object="$xdir$non_pic_object" + + # A standard non-PIC object + func_append non_pic_objects " $non_pic_object" + if test -z "$pic_object" || test "$pic_object" = none ; then + arg="$non_pic_object" + fi + else + # If the PIC object exists, use it instead. + # $xdir was prepended to $pic_object above. + non_pic_object="$pic_object" + func_append non_pic_objects " $non_pic_object" + fi + else + # Only an error if not doing a dry-run. + if $opt_dry_run; then + # Extract subdirectory from the argument. + func_dirname "$arg" "/" "" + xdir="$func_dirname_result" + + func_lo2o "$arg" + pic_object=$xdir$objdir/$func_lo2o_result + non_pic_object=$xdir$func_lo2o_result + func_append libobjs " $pic_object" + func_append non_pic_objects " $non_pic_object" + else + func_fatal_error "\`$arg' is not a valid libtool object" + fi + fi + done + else + func_fatal_error "link input file \`$arg' does not exist" + fi + arg=$save_arg + prev= + continue + ;; + precious_regex) + precious_files_regex="$arg" + prev= + continue + ;; + release) + release="-$arg" + prev= + continue + ;; + rpath | xrpath) + # We need an absolute path. + case $arg in + [\\/]* | [A-Za-z]:[\\/]*) ;; + *) + func_fatal_error "only absolute run-paths are allowed" + ;; + esac + if test "$prev" = rpath; then + case "$rpath " in + *" $arg "*) ;; + *) func_append rpath " $arg" ;; + esac + else + case "$xrpath " in + *" $arg "*) ;; + *) func_append xrpath " $arg" ;; + esac + fi + prev= + continue + ;; + shrext) + shrext_cmds="$arg" + prev= + continue + ;; + weak) + func_append weak_libs " $arg" + prev= + continue + ;; + xcclinker) + func_append linker_flags " $qarg" + func_append compiler_flags " $qarg" + prev= + func_append compile_command " $qarg" + func_append finalize_command " $qarg" + continue + ;; + xcompiler) + func_append compiler_flags " $qarg" + prev= + func_append compile_command " $qarg" + func_append finalize_command " $qarg" + continue + ;; + xlinker) + func_append linker_flags " $qarg" + func_append compiler_flags " $wl$qarg" + prev= + func_append compile_command " $wl$qarg" + func_append finalize_command " $wl$qarg" + continue + ;; + *) + eval "$prev=\"\$arg\"" + prev= + continue + ;; + esac + fi # test -n "$prev" + + prevarg="$arg" + + case $arg in + -all-static) + if test -n "$link_static_flag"; then + # See comment for -static flag below, for more details. + func_append compile_command " $link_static_flag" + func_append finalize_command " $link_static_flag" + fi + continue + ;; + + -allow-undefined) + # FIXME: remove this flag sometime in the future. + func_fatal_error "\`-allow-undefined' must not be used because it is the default" + ;; + + -avoid-version) + avoid_version=yes + continue + ;; + + -bindir) + prev=bindir + continue + ;; + + -dlopen) + prev=dlfiles + continue + ;; + + -dlpreopen) + prev=dlprefiles + continue + ;; + + -export-dynamic) + export_dynamic=yes + continue + ;; + + -export-symbols | -export-symbols-regex) + if test -n "$export_symbols" || test -n "$export_symbols_regex"; then + func_fatal_error "more than one -exported-symbols argument is not allowed" + fi + if test "X$arg" = "X-export-symbols"; then + prev=expsyms + else + prev=expsyms_regex + fi + continue + ;; + + -framework) + prev=framework + continue + ;; + + -inst-prefix-dir) + prev=inst_prefix + continue + ;; + + # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:* + # so, if we see these flags be careful not to treat them like -L + -L[A-Z][A-Z]*:*) + case $with_gcc/$host in + no/*-*-irix* | /*-*-irix*) + func_append compile_command " $arg" + func_append finalize_command " $arg" + ;; + esac + continue + ;; + + -L*) + func_stripname "-L" '' "$arg" + if test -z "$func_stripname_result"; then + if test "$#" -gt 0; then + func_fatal_error "require no space between \`-L' and \`$1'" + else + func_fatal_error "need path for \`-L' option" + fi + fi + func_resolve_sysroot "$func_stripname_result" + dir=$func_resolve_sysroot_result + # We need an absolute path. + case $dir in + [\\/]* | [A-Za-z]:[\\/]*) ;; + *) + absdir=`cd "$dir" && pwd` + test -z "$absdir" && \ + func_fatal_error "cannot determine absolute directory name of \`$dir'" + dir="$absdir" + ;; + esac + case "$deplibs " in + *" -L$dir "* | *" $arg "*) + # Will only happen for absolute or sysroot arguments + ;; + *) + # Preserve sysroot, but never include relative directories + case $dir in + [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;; + *) func_append deplibs " -L$dir" ;; + esac + func_append lib_search_path " $dir" + ;; + esac + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) + testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'` + case :$dllsearchpath: in + *":$dir:"*) ;; + ::) dllsearchpath=$dir;; + *) func_append dllsearchpath ":$dir";; + esac + case :$dllsearchpath: in + *":$testbindir:"*) ;; + ::) dllsearchpath=$testbindir;; + *) func_append dllsearchpath ":$testbindir";; + esac + ;; + esac + continue + ;; + + -l*) + if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*) + # These systems don't actually have a C or math library (as such) + continue + ;; + *-*-os2*) + # These systems don't actually have a C library (as such) + test "X$arg" = "X-lc" && continue + ;; + *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*) + # Do not include libc due to us having libc/libc_r. + test "X$arg" = "X-lc" && continue + ;; + *-*-rhapsody* | *-*-darwin1.[012]) + # Rhapsody C and math libraries are in the System framework + func_append deplibs " System.ltframework" + continue + ;; + *-*-sco3.2v5* | *-*-sco5v6*) + # Causes problems with __ctype + test "X$arg" = "X-lc" && continue + ;; + *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*) + # Compiler inserts libc in the correct place for threads to work + test "X$arg" = "X-lc" && continue + ;; + esac + elif test "X$arg" = "X-lc_r"; then + case $host in + *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*) + # Do not include libc_r directly, use -pthread flag. + continue + ;; + esac + fi + func_append deplibs " $arg" + continue + ;; + + -module) + module=yes + continue + ;; + + # Tru64 UNIX uses -model [arg] to determine the layout of C++ + # classes, name mangling, and exception handling. + # Darwin uses the -arch flag to determine output architecture. + -model|-arch|-isysroot|--sysroot) + func_append compiler_flags " $arg" + func_append compile_command " $arg" + func_append finalize_command " $arg" + prev=xcompiler + continue + ;; + + -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \ + |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*) + func_append compiler_flags " $arg" + func_append compile_command " $arg" + func_append finalize_command " $arg" + case "$new_inherited_linker_flags " in + *" $arg "*) ;; + * ) func_append new_inherited_linker_flags " $arg" ;; + esac + continue + ;; + + -multi_module) + single_module="${wl}-multi_module" + continue + ;; + + -no-fast-install) + fast_install=no + continue + ;; + + -no-install) + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*) + # The PATH hackery in wrapper scripts is required on Windows + # and Darwin in order for the loader to find any dlls it needs. + func_warning "\`-no-install' is ignored for $host" + func_warning "assuming \`-no-fast-install' instead" + fast_install=no + ;; + *) no_install=yes ;; + esac + continue + ;; + + -no-undefined) + allow_undefined=no + continue + ;; + + -objectlist) + prev=objectlist + continue + ;; + + -o) prev=output ;; + + -precious-files-regex) + prev=precious_regex + continue + ;; + + -release) + prev=release + continue + ;; + + -rpath) + prev=rpath + continue + ;; + + -R) + prev=xrpath + continue + ;; + + -R*) + func_stripname '-R' '' "$arg" + dir=$func_stripname_result + # We need an absolute path. + case $dir in + [\\/]* | [A-Za-z]:[\\/]*) ;; + =*) + func_stripname '=' '' "$dir" + dir=$lt_sysroot$func_stripname_result + ;; + *) + func_fatal_error "only absolute run-paths are allowed" + ;; + esac + case "$xrpath " in + *" $dir "*) ;; + *) func_append xrpath " $dir" ;; + esac + continue + ;; + + -shared) + # The effects of -shared are defined in a previous loop. + continue + ;; + + -shrext) + prev=shrext + continue + ;; + + -static | -static-libtool-libs) + # The effects of -static are defined in a previous loop. + # We used to do the same as -all-static on platforms that + # didn't have a PIC flag, but the assumption that the effects + # would be equivalent was wrong. It would break on at least + # Digital Unix and AIX. + continue + ;; + + -thread-safe) + thread_safe=yes + continue + ;; + + -version-info) + prev=vinfo + continue + ;; + + -version-number) + prev=vinfo + vinfo_number=yes + continue + ;; + + -weak) + prev=weak + continue + ;; + + -Wc,*) + func_stripname '-Wc,' '' "$arg" + args=$func_stripname_result + arg= + save_ifs="$IFS"; IFS=',' + for flag in $args; do + IFS="$save_ifs" + func_quote_for_eval "$flag" + func_append arg " $func_quote_for_eval_result" + func_append compiler_flags " $func_quote_for_eval_result" + done + IFS="$save_ifs" + func_stripname ' ' '' "$arg" + arg=$func_stripname_result + ;; + + -Wl,*) + func_stripname '-Wl,' '' "$arg" + args=$func_stripname_result + arg= + save_ifs="$IFS"; IFS=',' + for flag in $args; do + IFS="$save_ifs" + func_quote_for_eval "$flag" + func_append arg " $wl$func_quote_for_eval_result" + func_append compiler_flags " $wl$func_quote_for_eval_result" + func_append linker_flags " $func_quote_for_eval_result" + done + IFS="$save_ifs" + func_stripname ' ' '' "$arg" + arg=$func_stripname_result + ;; + + -Xcompiler) + prev=xcompiler + continue + ;; + + -Xlinker) + prev=xlinker + continue + ;; + + -XCClinker) + prev=xcclinker + continue + ;; + + # -msg_* for osf cc + -msg_*) + func_quote_for_eval "$arg" + arg="$func_quote_for_eval_result" + ;; + + # Flags to be passed through unchanged, with rationale: + # -64, -mips[0-9] enable 64-bit mode for the SGI compiler + # -r[0-9][0-9]* specify processor for the SGI compiler + # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler + # +DA*, +DD* enable 64-bit mode for the HP compiler + # -q* compiler args for the IBM compiler + # -m*, -t[45]*, -txscale* architecture-specific flags for GCC + # -F/path path to uninstalled frameworks, gcc on darwin + # -p, -pg, --coverage, -fprofile-* profiling flags for GCC + # @file GCC response files + # -tp=* Portland pgcc target processor selection + # --sysroot=* for sysroot support + # -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization + -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \ + -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \ + -O*|-flto*|-fwhopr*|-fuse-linker-plugin) + func_quote_for_eval "$arg" + arg="$func_quote_for_eval_result" + func_append compile_command " $arg" + func_append finalize_command " $arg" + func_append compiler_flags " $arg" + continue + ;; + + # Some other compiler flag. + -* | +*) + func_quote_for_eval "$arg" + arg="$func_quote_for_eval_result" + ;; + + *.$objext) + # A standard object. + func_append objs " $arg" + ;; + + *.lo) + # A libtool-controlled object. + + # Check to see that this really is a libtool object. + if func_lalib_unsafe_p "$arg"; then + pic_object= + non_pic_object= + + # Read the .lo file + func_source "$arg" + + if test -z "$pic_object" || + test -z "$non_pic_object" || + test "$pic_object" = none && + test "$non_pic_object" = none; then + func_fatal_error "cannot find name of object for \`$arg'" + fi + + # Extract subdirectory from the argument. + func_dirname "$arg" "/" "" + xdir="$func_dirname_result" + + if test "$pic_object" != none; then + # Prepend the subdirectory the object is found in. + pic_object="$xdir$pic_object" + + if test "$prev" = dlfiles; then + if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then + func_append dlfiles " $pic_object" + prev= + continue + else + # If libtool objects are unsupported, then we need to preload. + prev=dlprefiles + fi + fi + + # CHECK ME: I think I busted this. -Ossama + if test "$prev" = dlprefiles; then + # Preload the old-style object. + func_append dlprefiles " $pic_object" + prev= + fi + + # A PIC object. + func_append libobjs " $pic_object" + arg="$pic_object" + fi + + # Non-PIC object. + if test "$non_pic_object" != none; then + # Prepend the subdirectory the object is found in. + non_pic_object="$xdir$non_pic_object" + + # A standard non-PIC object + func_append non_pic_objects " $non_pic_object" + if test -z "$pic_object" || test "$pic_object" = none ; then + arg="$non_pic_object" + fi + else + # If the PIC object exists, use it instead. + # $xdir was prepended to $pic_object above. + non_pic_object="$pic_object" + func_append non_pic_objects " $non_pic_object" + fi + else + # Only an error if not doing a dry-run. + if $opt_dry_run; then + # Extract subdirectory from the argument. + func_dirname "$arg" "/" "" + xdir="$func_dirname_result" + + func_lo2o "$arg" + pic_object=$xdir$objdir/$func_lo2o_result + non_pic_object=$xdir$func_lo2o_result + func_append libobjs " $pic_object" + func_append non_pic_objects " $non_pic_object" + else + func_fatal_error "\`$arg' is not a valid libtool object" + fi + fi + ;; + + *.$libext) + # An archive. + func_append deplibs " $arg" + func_append old_deplibs " $arg" + continue + ;; + + *.la) + # A libtool-controlled library. + + func_resolve_sysroot "$arg" + if test "$prev" = dlfiles; then + # This library was specified with -dlopen. + func_append dlfiles " $func_resolve_sysroot_result" + prev= + elif test "$prev" = dlprefiles; then + # The library was specified with -dlpreopen. + func_append dlprefiles " $func_resolve_sysroot_result" + prev= + else + func_append deplibs " $func_resolve_sysroot_result" + fi + continue + ;; + + # Some other compiler argument. + *) + # Unknown arguments in both finalize_command and compile_command need + # to be aesthetically quoted because they are evaled later. + func_quote_for_eval "$arg" + arg="$func_quote_for_eval_result" + ;; + esac # arg + + # Now actually substitute the argument into the commands. + if test -n "$arg"; then + func_append compile_command " $arg" + func_append finalize_command " $arg" + fi + done # argument parsing loop + + test -n "$prev" && \ + func_fatal_help "the \`$prevarg' option requires an argument" + + if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then + eval arg=\"$export_dynamic_flag_spec\" + func_append compile_command " $arg" + func_append finalize_command " $arg" + fi + + oldlibs= + # calculate the name of the file, without its directory + func_basename "$output" + outputname="$func_basename_result" + libobjs_save="$libobjs" + + if test -n "$shlibpath_var"; then + # get the directories listed in $shlibpath_var + eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\` + else + shlib_search_path= + fi + eval sys_lib_search_path=\"$sys_lib_search_path_spec\" + eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\" + + func_dirname "$output" "/" "" + output_objdir="$func_dirname_result$objdir" + func_to_tool_file "$output_objdir/" + tool_output_objdir=$func_to_tool_file_result + # Create the object directory. + func_mkdir_p "$output_objdir" + + # Determine the type of output + case $output in + "") + func_fatal_help "you must specify an output file" + ;; + *.$libext) linkmode=oldlib ;; + *.lo | *.$objext) linkmode=obj ;; + *.la) linkmode=lib ;; + *) linkmode=prog ;; # Anything else should be a program. + esac + + specialdeplibs= + + libs= + # Find all interdependent deplibs by searching for libraries + # that are linked more than once (e.g. -la -lb -la) + for deplib in $deplibs; do + if $opt_preserve_dup_deps ; then + case "$libs " in + *" $deplib "*) func_append specialdeplibs " $deplib" ;; + esac + fi + func_append libs " $deplib" + done + + if test "$linkmode" = lib; then + libs="$predeps $libs $compiler_lib_search_path $postdeps" + + # Compute libraries that are listed more than once in $predeps + # $postdeps and mark them as special (i.e., whose duplicates are + # not to be eliminated). + pre_post_deps= + if $opt_duplicate_compiler_generated_deps; then + for pre_post_dep in $predeps $postdeps; do + case "$pre_post_deps " in + *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;; + esac + func_append pre_post_deps " $pre_post_dep" + done + fi + pre_post_deps= + fi + + deplibs= + newdependency_libs= + newlib_search_path= + need_relink=no # whether we're linking any uninstalled libtool libraries + notinst_deplibs= # not-installed libtool libraries + notinst_path= # paths that contain not-installed libtool libraries + + case $linkmode in + lib) + passes="conv dlpreopen link" + for file in $dlfiles $dlprefiles; do + case $file in + *.la) ;; + *) + func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file" + ;; + esac + done + ;; + prog) + compile_deplibs= + finalize_deplibs= + alldeplibs=no + newdlfiles= + newdlprefiles= + passes="conv scan dlopen dlpreopen link" + ;; + *) passes="conv" + ;; + esac + + for pass in $passes; do + # The preopen pass in lib mode reverses $deplibs; put it back here + # so that -L comes before libs that need it for instance... + if test "$linkmode,$pass" = "lib,link"; then + ## FIXME: Find the place where the list is rebuilt in the wrong + ## order, and fix it there properly + tmp_deplibs= + for deplib in $deplibs; do + tmp_deplibs="$deplib $tmp_deplibs" + done + deplibs="$tmp_deplibs" + fi + + if test "$linkmode,$pass" = "lib,link" || + test "$linkmode,$pass" = "prog,scan"; then + libs="$deplibs" + deplibs= + fi + if test "$linkmode" = prog; then + case $pass in + dlopen) libs="$dlfiles" ;; + dlpreopen) libs="$dlprefiles" ;; + link) + libs="$deplibs %DEPLIBS%" + test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs" + ;; + esac + fi + if test "$linkmode,$pass" = "lib,dlpreopen"; then + # Collect and forward deplibs of preopened libtool libs + for lib in $dlprefiles; do + # Ignore non-libtool-libs + dependency_libs= + func_resolve_sysroot "$lib" + case $lib in + *.la) func_source "$func_resolve_sysroot_result" ;; + esac + + # Collect preopened libtool deplibs, except any this library + # has declared as weak libs + for deplib in $dependency_libs; do + func_basename "$deplib" + deplib_base=$func_basename_result + case " $weak_libs " in + *" $deplib_base "*) ;; + *) func_append deplibs " $deplib" ;; + esac + done + done + libs="$dlprefiles" + fi + if test "$pass" = dlopen; then + # Collect dlpreopened libraries + save_deplibs="$deplibs" + deplibs= + fi + + for deplib in $libs; do + lib= + found=no + case $deplib in + -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \ + |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*) + if test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + func_append compiler_flags " $deplib" + if test "$linkmode" = lib ; then + case "$new_inherited_linker_flags " in + *" $deplib "*) ;; + * ) func_append new_inherited_linker_flags " $deplib" ;; + esac + fi + fi + continue + ;; + -l*) + if test "$linkmode" != lib && test "$linkmode" != prog; then + func_warning "\`-l' is ignored for archives/objects" + continue + fi + func_stripname '-l' '' "$deplib" + name=$func_stripname_result + if test "$linkmode" = lib; then + searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path" + else + searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path" + fi + for searchdir in $searchdirs; do + for search_ext in .la $std_shrext .so .a; do + # Search the libtool library + lib="$searchdir/lib${name}${search_ext}" + if test -f "$lib"; then + if test "$search_ext" = ".la"; then + found=yes + else + found=no + fi + break 2 + fi + done + done + if test "$found" != yes; then + # deplib doesn't seem to be a libtool library + if test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + deplibs="$deplib $deplibs" + test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs" + fi + continue + else # deplib is a libtool library + # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib, + # We need to do some special things here, and not later. + if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then + case " $predeps $postdeps " in + *" $deplib "*) + if func_lalib_p "$lib"; then + library_names= + old_library= + func_source "$lib" + for l in $old_library $library_names; do + ll="$l" + done + if test "X$ll" = "X$old_library" ; then # only static version available + found=no + func_dirname "$lib" "" "." + ladir="$func_dirname_result" + lib=$ladir/$old_library + if test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + deplibs="$deplib $deplibs" + test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs" + fi + continue + fi + fi + ;; + *) ;; + esac + fi + fi + ;; # -l + *.ltframework) + if test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + deplibs="$deplib $deplibs" + if test "$linkmode" = lib ; then + case "$new_inherited_linker_flags " in + *" $deplib "*) ;; + * ) func_append new_inherited_linker_flags " $deplib" ;; + esac + fi + fi + continue + ;; + -L*) + case $linkmode in + lib) + deplibs="$deplib $deplibs" + test "$pass" = conv && continue + newdependency_libs="$deplib $newdependency_libs" + func_stripname '-L' '' "$deplib" + func_resolve_sysroot "$func_stripname_result" + func_append newlib_search_path " $func_resolve_sysroot_result" + ;; + prog) + if test "$pass" = conv; then + deplibs="$deplib $deplibs" + continue + fi + if test "$pass" = scan; then + deplibs="$deplib $deplibs" + else + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + fi + func_stripname '-L' '' "$deplib" + func_resolve_sysroot "$func_stripname_result" + func_append newlib_search_path " $func_resolve_sysroot_result" + ;; + *) + func_warning "\`-L' is ignored for archives/objects" + ;; + esac # linkmode + continue + ;; # -L + -R*) + if test "$pass" = link; then + func_stripname '-R' '' "$deplib" + func_resolve_sysroot "$func_stripname_result" + dir=$func_resolve_sysroot_result + # Make sure the xrpath contains only unique directories. + case "$xrpath " in + *" $dir "*) ;; + *) func_append xrpath " $dir" ;; + esac + fi + deplibs="$deplib $deplibs" + continue + ;; + *.la) + func_resolve_sysroot "$deplib" + lib=$func_resolve_sysroot_result + ;; + *.$libext) + if test "$pass" = conv; then + deplibs="$deplib $deplibs" + continue + fi + case $linkmode in + lib) + # Linking convenience modules into shared libraries is allowed, + # but linking other static libraries is non-portable. + case " $dlpreconveniencelibs " in + *" $deplib "*) ;; + *) + valid_a_lib=no + case $deplibs_check_method in + match_pattern*) + set dummy $deplibs_check_method; shift + match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"` + if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \ + | $EGREP "$match_pattern_regex" > /dev/null; then + valid_a_lib=yes + fi + ;; + pass_all) + valid_a_lib=yes + ;; + esac + if test "$valid_a_lib" != yes; then + echo + $ECHO "*** Warning: Trying to link with static lib archive $deplib." + echo "*** I have the capability to make that library automatically link in when" + echo "*** you link to this library. But I can only do this if you have a" + echo "*** shared version of the library, which you do not appear to have" + echo "*** because the file extensions .$libext of this argument makes me believe" + echo "*** that it is just a static archive that I should not use here." + else + echo + $ECHO "*** Warning: Linking the shared library $output against the" + $ECHO "*** static library $deplib is not portable!" + deplibs="$deplib $deplibs" + fi + ;; + esac + continue + ;; + prog) + if test "$pass" != link; then + deplibs="$deplib $deplibs" + else + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + fi + continue + ;; + esac # linkmode + ;; # *.$libext + *.lo | *.$objext) + if test "$pass" = conv; then + deplibs="$deplib $deplibs" + elif test "$linkmode" = prog; then + if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then + # If there is no dlopen support or we're linking statically, + # we need to preload. + func_append newdlprefiles " $deplib" + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + func_append newdlfiles " $deplib" + fi + fi + continue + ;; + %DEPLIBS%) + alldeplibs=yes + continue + ;; + esac # case $deplib + + if test "$found" = yes || test -f "$lib"; then : + else + func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'" + fi + + # Check to see that this really is a libtool archive. + func_lalib_unsafe_p "$lib" \ + || func_fatal_error "\`$lib' is not a valid libtool archive" + + func_dirname "$lib" "" "." + ladir="$func_dirname_result" + + dlname= + dlopen= + dlpreopen= + libdir= + library_names= + old_library= + inherited_linker_flags= + # If the library was installed with an old release of libtool, + # it will not redefine variables installed, or shouldnotlink + installed=yes + shouldnotlink=no + avoidtemprpath= + + + # Read the .la file + func_source "$lib" + + # Convert "-framework foo" to "foo.ltframework" + if test -n "$inherited_linker_flags"; then + tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'` + for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do + case " $new_inherited_linker_flags " in + *" $tmp_inherited_linker_flag "*) ;; + *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";; + esac + done + fi + dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + if test "$linkmode,$pass" = "lib,link" || + test "$linkmode,$pass" = "prog,scan" || + { test "$linkmode" != prog && test "$linkmode" != lib; }; then + test -n "$dlopen" && func_append dlfiles " $dlopen" + test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen" + fi + + if test "$pass" = conv; then + # Only check for convenience libraries + deplibs="$lib $deplibs" + if test -z "$libdir"; then + if test -z "$old_library"; then + func_fatal_error "cannot find name of link library for \`$lib'" + fi + # It is a libtool convenience library, so add in its objects. + func_append convenience " $ladir/$objdir/$old_library" + func_append old_convenience " $ladir/$objdir/$old_library" + tmp_libs= + for deplib in $dependency_libs; do + deplibs="$deplib $deplibs" + if $opt_preserve_dup_deps ; then + case "$tmp_libs " in + *" $deplib "*) func_append specialdeplibs " $deplib" ;; + esac + fi + func_append tmp_libs " $deplib" + done + elif test "$linkmode" != prog && test "$linkmode" != lib; then + func_fatal_error "\`$lib' is not a convenience library" + fi + continue + fi # $pass = conv + + + # Get the name of the library we link against. + linklib= + if test -n "$old_library" && + { test "$prefer_static_libs" = yes || + test "$prefer_static_libs,$installed" = "built,no"; }; then + linklib=$old_library + else + for l in $old_library $library_names; do + linklib="$l" + done + fi + if test -z "$linklib"; then + func_fatal_error "cannot find name of link library for \`$lib'" + fi + + # This library was specified with -dlopen. + if test "$pass" = dlopen; then + if test -z "$libdir"; then + func_fatal_error "cannot -dlopen a convenience library: \`$lib'" + fi + if test -z "$dlname" || + test "$dlopen_support" != yes || + test "$build_libtool_libs" = no; then + # If there is no dlname, no dlopen support or we're linking + # statically, we need to preload. We also need to preload any + # dependent libraries so libltdl's deplib preloader doesn't + # bomb out in the load deplibs phase. + func_append dlprefiles " $lib $dependency_libs" + else + func_append newdlfiles " $lib" + fi + continue + fi # $pass = dlopen + + # We need an absolute path. + case $ladir in + [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;; + *) + abs_ladir=`cd "$ladir" && pwd` + if test -z "$abs_ladir"; then + func_warning "cannot determine absolute directory name of \`$ladir'" + func_warning "passing it literally to the linker, although it might fail" + abs_ladir="$ladir" + fi + ;; + esac + func_basename "$lib" + laname="$func_basename_result" + + # Find the relevant object directory and library name. + if test "X$installed" = Xyes; then + if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then + func_warning "library \`$lib' was moved." + dir="$ladir" + absdir="$abs_ladir" + libdir="$abs_ladir" + else + dir="$lt_sysroot$libdir" + absdir="$lt_sysroot$libdir" + fi + test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes + else + if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then + dir="$ladir" + absdir="$abs_ladir" + # Remove this search path later + func_append notinst_path " $abs_ladir" + else + dir="$ladir/$objdir" + absdir="$abs_ladir/$objdir" + # Remove this search path later + func_append notinst_path " $abs_ladir" + fi + fi # $installed = yes + func_stripname 'lib' '.la' "$laname" + name=$func_stripname_result + + # This library was specified with -dlpreopen. + if test "$pass" = dlpreopen; then + if test -z "$libdir" && test "$linkmode" = prog; then + func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'" + fi + case "$host" in + # special handling for platforms with PE-DLLs. + *cygwin* | *mingw* | *cegcc* ) + # Linker will automatically link against shared library if both + # static and shared are present. Therefore, ensure we extract + # symbols from the import library if a shared library is present + # (otherwise, the dlopen module name will be incorrect). We do + # this by putting the import library name into $newdlprefiles. + # We recover the dlopen module name by 'saving' the la file + # name in a special purpose variable, and (later) extracting the + # dlname from the la file. + if test -n "$dlname"; then + func_tr_sh "$dir/$linklib" + eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname" + func_append newdlprefiles " $dir/$linklib" + else + func_append newdlprefiles " $dir/$old_library" + # Keep a list of preopened convenience libraries to check + # that they are being used correctly in the link pass. + test -z "$libdir" && \ + func_append dlpreconveniencelibs " $dir/$old_library" + fi + ;; + * ) + # Prefer using a static library (so that no silly _DYNAMIC symbols + # are required to link). + if test -n "$old_library"; then + func_append newdlprefiles " $dir/$old_library" + # Keep a list of preopened convenience libraries to check + # that they are being used correctly in the link pass. + test -z "$libdir" && \ + func_append dlpreconveniencelibs " $dir/$old_library" + # Otherwise, use the dlname, so that lt_dlopen finds it. + elif test -n "$dlname"; then + func_append newdlprefiles " $dir/$dlname" + else + func_append newdlprefiles " $dir/$linklib" + fi + ;; + esac + fi # $pass = dlpreopen + + if test -z "$libdir"; then + # Link the convenience library + if test "$linkmode" = lib; then + deplibs="$dir/$old_library $deplibs" + elif test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$dir/$old_library $compile_deplibs" + finalize_deplibs="$dir/$old_library $finalize_deplibs" + else + deplibs="$lib $deplibs" # used for prog,scan pass + fi + continue + fi + + + if test "$linkmode" = prog && test "$pass" != link; then + func_append newlib_search_path " $ladir" + deplibs="$lib $deplibs" + + linkalldeplibs=no + if test "$link_all_deplibs" != no || test -z "$library_names" || + test "$build_libtool_libs" = no; then + linkalldeplibs=yes + fi + + tmp_libs= + for deplib in $dependency_libs; do + case $deplib in + -L*) func_stripname '-L' '' "$deplib" + func_resolve_sysroot "$func_stripname_result" + func_append newlib_search_path " $func_resolve_sysroot_result" + ;; + esac + # Need to link against all dependency_libs? + if test "$linkalldeplibs" = yes; then + deplibs="$deplib $deplibs" + else + # Need to hardcode shared library paths + # or/and link against static libraries + newdependency_libs="$deplib $newdependency_libs" + fi + if $opt_preserve_dup_deps ; then + case "$tmp_libs " in + *" $deplib "*) func_append specialdeplibs " $deplib" ;; + esac + fi + func_append tmp_libs " $deplib" + done # for deplib + continue + fi # $linkmode = prog... + + if test "$linkmode,$pass" = "prog,link"; then + if test -n "$library_names" && + { { test "$prefer_static_libs" = no || + test "$prefer_static_libs,$installed" = "built,yes"; } || + test -z "$old_library"; }; then + # We need to hardcode the library path + if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then + # Make sure the rpath contains only unique directories. + case "$temp_rpath:" in + *"$absdir:"*) ;; + *) func_append temp_rpath "$absdir:" ;; + esac + fi + + # Hardcode the library path. + # Skip directories that are in the system default run-time + # search path. + case " $sys_lib_dlsearch_path " in + *" $absdir "*) ;; + *) + case "$compile_rpath " in + *" $absdir "*) ;; + *) func_append compile_rpath " $absdir" ;; + esac + ;; + esac + case " $sys_lib_dlsearch_path " in + *" $libdir "*) ;; + *) + case "$finalize_rpath " in + *" $libdir "*) ;; + *) func_append finalize_rpath " $libdir" ;; + esac + ;; + esac + fi # $linkmode,$pass = prog,link... + + if test "$alldeplibs" = yes && + { test "$deplibs_check_method" = pass_all || + { test "$build_libtool_libs" = yes && + test -n "$library_names"; }; }; then + # We only need to search for static libraries + continue + fi + fi + + link_static=no # Whether the deplib will be linked statically + use_static_libs=$prefer_static_libs + if test "$use_static_libs" = built && test "$installed" = yes; then + use_static_libs=no + fi + if test -n "$library_names" && + { test "$use_static_libs" = no || test -z "$old_library"; }; then + case $host in + *cygwin* | *mingw* | *cegcc*) + # No point in relinking DLLs because paths are not encoded + func_append notinst_deplibs " $lib" + need_relink=no + ;; + *) + if test "$installed" = no; then + func_append notinst_deplibs " $lib" + need_relink=yes + fi + ;; + esac + # This is a shared library + + # Warn about portability, can't link against -module's on some + # systems (darwin). Don't bleat about dlopened modules though! + dlopenmodule="" + for dlpremoduletest in $dlprefiles; do + if test "X$dlpremoduletest" = "X$lib"; then + dlopenmodule="$dlpremoduletest" + break + fi + done + if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then + echo + if test "$linkmode" = prog; then + $ECHO "*** Warning: Linking the executable $output against the loadable module" + else + $ECHO "*** Warning: Linking the shared library $output against the loadable module" + fi + $ECHO "*** $linklib is not portable!" + fi + if test "$linkmode" = lib && + test "$hardcode_into_libs" = yes; then + # Hardcode the library path. + # Skip directories that are in the system default run-time + # search path. + case " $sys_lib_dlsearch_path " in + *" $absdir "*) ;; + *) + case "$compile_rpath " in + *" $absdir "*) ;; + *) func_append compile_rpath " $absdir" ;; + esac + ;; + esac + case " $sys_lib_dlsearch_path " in + *" $libdir "*) ;; + *) + case "$finalize_rpath " in + *" $libdir "*) ;; + *) func_append finalize_rpath " $libdir" ;; + esac + ;; + esac + fi + + if test -n "$old_archive_from_expsyms_cmds"; then + # figure out the soname + set dummy $library_names + shift + realname="$1" + shift + libname=`eval "\\$ECHO \"$libname_spec\""` + # use dlname if we got it. it's perfectly good, no? + if test -n "$dlname"; then + soname="$dlname" + elif test -n "$soname_spec"; then + # bleh windows + case $host in + *cygwin* | mingw* | *cegcc*) + func_arith $current - $age + major=$func_arith_result + versuffix="-$major" + ;; + esac + eval soname=\"$soname_spec\" + else + soname="$realname" + fi + + # Make a new name for the extract_expsyms_cmds to use + soroot="$soname" + func_basename "$soroot" + soname="$func_basename_result" + func_stripname 'lib' '.dll' "$soname" + newlib=libimp-$func_stripname_result.a + + # If the library has no export list, then create one now + if test -f "$output_objdir/$soname-def"; then : + else + func_verbose "extracting exported symbol list from \`$soname'" + func_execute_cmds "$extract_expsyms_cmds" 'exit $?' + fi + + # Create $newlib + if test -f "$output_objdir/$newlib"; then :; else + func_verbose "generating import library for \`$soname'" + func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?' + fi + # make sure the library variables are pointing to the new library + dir=$output_objdir + linklib=$newlib + fi # test -n "$old_archive_from_expsyms_cmds" + + if test "$linkmode" = prog || test "$opt_mode" != relink; then + add_shlibpath= + add_dir= + add= + lib_linked=yes + case $hardcode_action in + immediate | unsupported) + if test "$hardcode_direct" = no; then + add="$dir/$linklib" + case $host in + *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;; + *-*-sysv4*uw2*) add_dir="-L$dir" ;; + *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \ + *-*-unixware7*) add_dir="-L$dir" ;; + *-*-darwin* ) + # if the lib is a (non-dlopened) module then we can not + # link against it, someone is ignoring the earlier warnings + if /usr/bin/file -L $add 2> /dev/null | + $GREP ": [^:]* bundle" >/dev/null ; then + if test "X$dlopenmodule" != "X$lib"; then + $ECHO "*** Warning: lib $linklib is a module, not a shared library" + if test -z "$old_library" ; then + echo + echo "*** And there doesn't seem to be a static archive available" + echo "*** The link will probably fail, sorry" + else + add="$dir/$old_library" + fi + elif test -n "$old_library"; then + add="$dir/$old_library" + fi + fi + esac + elif test "$hardcode_minus_L" = no; then + case $host in + *-*-sunos*) add_shlibpath="$dir" ;; + esac + add_dir="-L$dir" + add="-l$name" + elif test "$hardcode_shlibpath_var" = no; then + add_shlibpath="$dir" + add="-l$name" + else + lib_linked=no + fi + ;; + relink) + if test "$hardcode_direct" = yes && + test "$hardcode_direct_absolute" = no; then + add="$dir/$linklib" + elif test "$hardcode_minus_L" = yes; then + add_dir="-L$absdir" + # Try looking first in the location we're being installed to. + if test -n "$inst_prefix_dir"; then + case $libdir in + [\\/]*) + func_append add_dir " -L$inst_prefix_dir$libdir" + ;; + esac + fi + add="-l$name" + elif test "$hardcode_shlibpath_var" = yes; then + add_shlibpath="$dir" + add="-l$name" + else + lib_linked=no + fi + ;; + *) lib_linked=no ;; + esac + + if test "$lib_linked" != yes; then + func_fatal_configuration "unsupported hardcode properties" + fi + + if test -n "$add_shlibpath"; then + case :$compile_shlibpath: in + *":$add_shlibpath:"*) ;; + *) func_append compile_shlibpath "$add_shlibpath:" ;; + esac + fi + if test "$linkmode" = prog; then + test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs" + test -n "$add" && compile_deplibs="$add $compile_deplibs" + else + test -n "$add_dir" && deplibs="$add_dir $deplibs" + test -n "$add" && deplibs="$add $deplibs" + if test "$hardcode_direct" != yes && + test "$hardcode_minus_L" != yes && + test "$hardcode_shlibpath_var" = yes; then + case :$finalize_shlibpath: in + *":$libdir:"*) ;; + *) func_append finalize_shlibpath "$libdir:" ;; + esac + fi + fi + fi + + if test "$linkmode" = prog || test "$opt_mode" = relink; then + add_shlibpath= + add_dir= + add= + # Finalize command for both is simple: just hardcode it. + if test "$hardcode_direct" = yes && + test "$hardcode_direct_absolute" = no; then + add="$libdir/$linklib" + elif test "$hardcode_minus_L" = yes; then + add_dir="-L$libdir" + add="-l$name" + elif test "$hardcode_shlibpath_var" = yes; then + case :$finalize_shlibpath: in + *":$libdir:"*) ;; + *) func_append finalize_shlibpath "$libdir:" ;; + esac + add="-l$name" + elif test "$hardcode_automatic" = yes; then + if test -n "$inst_prefix_dir" && + test -f "$inst_prefix_dir$libdir/$linklib" ; then + add="$inst_prefix_dir$libdir/$linklib" + else + add="$libdir/$linklib" + fi + else + # We cannot seem to hardcode it, guess we'll fake it. + add_dir="-L$libdir" + # Try looking first in the location we're being installed to. + if test -n "$inst_prefix_dir"; then + case $libdir in + [\\/]*) + func_append add_dir " -L$inst_prefix_dir$libdir" + ;; + esac + fi + add="-l$name" + fi + + if test "$linkmode" = prog; then + test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs" + test -n "$add" && finalize_deplibs="$add $finalize_deplibs" + else + test -n "$add_dir" && deplibs="$add_dir $deplibs" + test -n "$add" && deplibs="$add $deplibs" + fi + fi + elif test "$linkmode" = prog; then + # Here we assume that one of hardcode_direct or hardcode_minus_L + # is not unsupported. This is valid on all known static and + # shared platforms. + if test "$hardcode_direct" != unsupported; then + test -n "$old_library" && linklib="$old_library" + compile_deplibs="$dir/$linklib $compile_deplibs" + finalize_deplibs="$dir/$linklib $finalize_deplibs" + else + compile_deplibs="-l$name -L$dir $compile_deplibs" + finalize_deplibs="-l$name -L$dir $finalize_deplibs" + fi + elif test "$build_libtool_libs" = yes; then + # Not a shared library + if test "$deplibs_check_method" != pass_all; then + # We're trying link a shared library against a static one + # but the system doesn't support it. + + # Just print a warning and add the library to dependency_libs so + # that the program can be linked against the static library. + echo + $ECHO "*** Warning: This system can not link to static lib archive $lib." + echo "*** I have the capability to make that library automatically link in when" + echo "*** you link to this library. But I can only do this if you have a" + echo "*** shared version of the library, which you do not appear to have." + if test "$module" = yes; then + echo "*** But as you try to build a module library, libtool will still create " + echo "*** a static module, that should work as long as the dlopening application" + echo "*** is linked with the -dlopen flag to resolve symbols at runtime." + if test -z "$global_symbol_pipe"; then + echo + echo "*** However, this would only work if libtool was able to extract symbol" + echo "*** lists from a program, using \`nm' or equivalent, but libtool could" + echo "*** not find such a program. So, this module is probably useless." + echo "*** \`nm' from GNU binutils and a full rebuild may help." + fi + if test "$build_old_libs" = no; then + build_libtool_libs=module + build_old_libs=yes + else + build_libtool_libs=no + fi + fi + else + deplibs="$dir/$old_library $deplibs" + link_static=yes + fi + fi # link shared/static library? + + if test "$linkmode" = lib; then + if test -n "$dependency_libs" && + { test "$hardcode_into_libs" != yes || + test "$build_old_libs" = yes || + test "$link_static" = yes; }; then + # Extract -R from dependency_libs + temp_deplibs= + for libdir in $dependency_libs; do + case $libdir in + -R*) func_stripname '-R' '' "$libdir" + temp_xrpath=$func_stripname_result + case " $xrpath " in + *" $temp_xrpath "*) ;; + *) func_append xrpath " $temp_xrpath";; + esac;; + *) func_append temp_deplibs " $libdir";; + esac + done + dependency_libs="$temp_deplibs" + fi + + func_append newlib_search_path " $absdir" + # Link against this library + test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs" + # ... and its dependency_libs + tmp_libs= + for deplib in $dependency_libs; do + newdependency_libs="$deplib $newdependency_libs" + case $deplib in + -L*) func_stripname '-L' '' "$deplib" + func_resolve_sysroot "$func_stripname_result";; + *) func_resolve_sysroot "$deplib" ;; + esac + if $opt_preserve_dup_deps ; then + case "$tmp_libs " in + *" $func_resolve_sysroot_result "*) + func_append specialdeplibs " $func_resolve_sysroot_result" ;; + esac + fi + func_append tmp_libs " $func_resolve_sysroot_result" + done + + if test "$link_all_deplibs" != no; then + # Add the search paths of all dependency libraries + for deplib in $dependency_libs; do + path= + case $deplib in + -L*) path="$deplib" ;; + *.la) + func_resolve_sysroot "$deplib" + deplib=$func_resolve_sysroot_result + func_dirname "$deplib" "" "." + dir=$func_dirname_result + # We need an absolute path. + case $dir in + [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;; + *) + absdir=`cd "$dir" && pwd` + if test -z "$absdir"; then + func_warning "cannot determine absolute directory name of \`$dir'" + absdir="$dir" + fi + ;; + esac + if $GREP "^installed=no" $deplib > /dev/null; then + case $host in + *-*-darwin*) + depdepl= + eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib` + if test -n "$deplibrary_names" ; then + for tmp in $deplibrary_names ; do + depdepl=$tmp + done + if test -f "$absdir/$objdir/$depdepl" ; then + depdepl="$absdir/$objdir/$depdepl" + darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'` + if test -z "$darwin_install_name"; then + darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'` + fi + func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}" + func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}" + path= + fi + fi + ;; + *) + path="-L$absdir/$objdir" + ;; + esac + else + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib` + test -z "$libdir" && \ + func_fatal_error "\`$deplib' is not a valid libtool archive" + test "$absdir" != "$libdir" && \ + func_warning "\`$deplib' seems to be moved" + + path="-L$absdir" + fi + ;; + esac + case " $deplibs " in + *" $path "*) ;; + *) deplibs="$path $deplibs" ;; + esac + done + fi # link_all_deplibs != no + fi # linkmode = lib + done # for deplib in $libs + if test "$pass" = link; then + if test "$linkmode" = "prog"; then + compile_deplibs="$new_inherited_linker_flags $compile_deplibs" + finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs" + else + compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + fi + fi + dependency_libs="$newdependency_libs" + if test "$pass" = dlpreopen; then + # Link the dlpreopened libraries before other libraries + for deplib in $save_deplibs; do + deplibs="$deplib $deplibs" + done + fi + if test "$pass" != dlopen; then + if test "$pass" != conv; then + # Make sure lib_search_path contains only unique directories. + lib_search_path= + for dir in $newlib_search_path; do + case "$lib_search_path " in + *" $dir "*) ;; + *) func_append lib_search_path " $dir" ;; + esac + done + newlib_search_path= + fi + + if test "$linkmode,$pass" != "prog,link"; then + vars="deplibs" + else + vars="compile_deplibs finalize_deplibs" + fi + for var in $vars dependency_libs; do + # Add libraries to $var in reverse order + eval tmp_libs=\"\$$var\" + new_libs= + for deplib in $tmp_libs; do + # FIXME: Pedantically, this is the right thing to do, so + # that some nasty dependency loop isn't accidentally + # broken: + #new_libs="$deplib $new_libs" + # Pragmatically, this seems to cause very few problems in + # practice: + case $deplib in + -L*) new_libs="$deplib $new_libs" ;; + -R*) ;; + *) + # And here is the reason: when a library appears more + # than once as an explicit dependence of a library, or + # is implicitly linked in more than once by the + # compiler, it is considered special, and multiple + # occurrences thereof are not removed. Compare this + # with having the same library being listed as a + # dependency of multiple other libraries: in this case, + # we know (pedantically, we assume) the library does not + # need to be listed more than once, so we keep only the + # last copy. This is not always right, but it is rare + # enough that we require users that really mean to play + # such unportable linking tricks to link the library + # using -Wl,-lname, so that libtool does not consider it + # for duplicate removal. + case " $specialdeplibs " in + *" $deplib "*) new_libs="$deplib $new_libs" ;; + *) + case " $new_libs " in + *" $deplib "*) ;; + *) new_libs="$deplib $new_libs" ;; + esac + ;; + esac + ;; + esac + done + tmp_libs= + for deplib in $new_libs; do + case $deplib in + -L*) + case " $tmp_libs " in + *" $deplib "*) ;; + *) func_append tmp_libs " $deplib" ;; + esac + ;; + *) func_append tmp_libs " $deplib" ;; + esac + done + eval $var=\"$tmp_libs\" + done # for var + fi + # Last step: remove runtime libs from dependency_libs + # (they stay in deplibs) + tmp_libs= + for i in $dependency_libs ; do + case " $predeps $postdeps $compiler_lib_search_path " in + *" $i "*) + i="" + ;; + esac + if test -n "$i" ; then + func_append tmp_libs " $i" + fi + done + dependency_libs=$tmp_libs + done # for pass + if test "$linkmode" = prog; then + dlfiles="$newdlfiles" + fi + if test "$linkmode" = prog || test "$linkmode" = lib; then + dlprefiles="$newdlprefiles" + fi + + case $linkmode in + oldlib) + if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then + func_warning "\`-dlopen' is ignored for archives" + fi + + case " $deplibs" in + *\ -l* | *\ -L*) + func_warning "\`-l' and \`-L' are ignored for archives" ;; + esac + + test -n "$rpath" && \ + func_warning "\`-rpath' is ignored for archives" + + test -n "$xrpath" && \ + func_warning "\`-R' is ignored for archives" + + test -n "$vinfo" && \ + func_warning "\`-version-info/-version-number' is ignored for archives" + + test -n "$release" && \ + func_warning "\`-release' is ignored for archives" + + test -n "$export_symbols$export_symbols_regex" && \ + func_warning "\`-export-symbols' is ignored for archives" + + # Now set the variables for building old libraries. + build_libtool_libs=no + oldlibs="$output" + func_append objs "$old_deplibs" + ;; + + lib) + # Make sure we only generate libraries of the form `libNAME.la'. + case $outputname in + lib*) + func_stripname 'lib' '.la' "$outputname" + name=$func_stripname_result + eval shared_ext=\"$shrext_cmds\" + eval libname=\"$libname_spec\" + ;; + *) + test "$module" = no && \ + func_fatal_help "libtool library \`$output' must begin with \`lib'" + + if test "$need_lib_prefix" != no; then + # Add the "lib" prefix for modules if required + func_stripname '' '.la' "$outputname" + name=$func_stripname_result + eval shared_ext=\"$shrext_cmds\" + eval libname=\"$libname_spec\" + else + func_stripname '' '.la' "$outputname" + libname=$func_stripname_result + fi + ;; + esac + + if test -n "$objs"; then + if test "$deplibs_check_method" != pass_all; then + func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs" + else + echo + $ECHO "*** Warning: Linking the shared library $output against the non-libtool" + $ECHO "*** objects $objs is not portable!" + func_append libobjs " $objs" + fi + fi + + test "$dlself" != no && \ + func_warning "\`-dlopen self' is ignored for libtool libraries" + + set dummy $rpath + shift + test "$#" -gt 1 && \ + func_warning "ignoring multiple \`-rpath's for a libtool library" + + install_libdir="$1" + + oldlibs= + if test -z "$rpath"; then + if test "$build_libtool_libs" = yes; then + # Building a libtool convenience library. + # Some compilers have problems with a `.al' extension so + # convenience libraries should have the same extension an + # archive normally would. + oldlibs="$output_objdir/$libname.$libext $oldlibs" + build_libtool_libs=convenience + build_old_libs=yes + fi + + test -n "$vinfo" && \ + func_warning "\`-version-info/-version-number' is ignored for convenience libraries" + + test -n "$release" && \ + func_warning "\`-release' is ignored for convenience libraries" + else + + # Parse the version information argument. + save_ifs="$IFS"; IFS=':' + set dummy $vinfo 0 0 0 + shift + IFS="$save_ifs" + + test -n "$7" && \ + func_fatal_help "too many parameters to \`-version-info'" + + # convert absolute version numbers to libtool ages + # this retains compatibility with .la files and attempts + # to make the code below a bit more comprehensible + + case $vinfo_number in + yes) + number_major="$1" + number_minor="$2" + number_revision="$3" + # + # There are really only two kinds -- those that + # use the current revision as the major version + # and those that subtract age and use age as + # a minor version. But, then there is irix + # which has an extra 1 added just for fun + # + case $version_type in + # correct linux to gnu/linux during the next big refactor + darwin|linux|osf|windows|none) + func_arith $number_major + $number_minor + current=$func_arith_result + age="$number_minor" + revision="$number_revision" + ;; + freebsd-aout|freebsd-elf|qnx|sunos) + current="$number_major" + revision="$number_minor" + age="0" + ;; + irix|nonstopux) + func_arith $number_major + $number_minor + current=$func_arith_result + age="$number_minor" + revision="$number_minor" + lt_irix_increment=no + ;; + *) + func_fatal_configuration "$modename: unknown library version type \`$version_type'" + ;; + esac + ;; + no) + current="$1" + revision="$2" + age="$3" + ;; + esac + + # Check that each of the things are valid numbers. + case $current in + 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;; + *) + func_error "CURRENT \`$current' must be a nonnegative integer" + func_fatal_error "\`$vinfo' is not valid version information" + ;; + esac + + case $revision in + 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;; + *) + func_error "REVISION \`$revision' must be a nonnegative integer" + func_fatal_error "\`$vinfo' is not valid version information" + ;; + esac + + case $age in + 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;; + *) + func_error "AGE \`$age' must be a nonnegative integer" + func_fatal_error "\`$vinfo' is not valid version information" + ;; + esac + + if test "$age" -gt "$current"; then + func_error "AGE \`$age' is greater than the current interface number \`$current'" + func_fatal_error "\`$vinfo' is not valid version information" + fi + + # Calculate the version variables. + major= + versuffix= + verstring= + case $version_type in + none) ;; + + darwin) + # Like Linux, but with the current version available in + # verstring for coding it into the library header + func_arith $current - $age + major=.$func_arith_result + versuffix="$major.$age.$revision" + # Darwin ld doesn't like 0 for these options... + func_arith $current + 1 + minor_current=$func_arith_result + xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision" + verstring="-compatibility_version $minor_current -current_version $minor_current.$revision" + ;; + + freebsd-aout) + major=".$current" + versuffix=".$current.$revision"; + ;; + + freebsd-elf) + major=".$current" + versuffix=".$current" + ;; + + irix | nonstopux) + if test "X$lt_irix_increment" = "Xno"; then + func_arith $current - $age + else + func_arith $current - $age + 1 + fi + major=$func_arith_result + + case $version_type in + nonstopux) verstring_prefix=nonstopux ;; + *) verstring_prefix=sgi ;; + esac + verstring="$verstring_prefix$major.$revision" + + # Add in all the interfaces that we are compatible with. + loop=$revision + while test "$loop" -ne 0; do + func_arith $revision - $loop + iface=$func_arith_result + func_arith $loop - 1 + loop=$func_arith_result + verstring="$verstring_prefix$major.$iface:$verstring" + done + + # Before this point, $major must not contain `.'. + major=.$major + versuffix="$major.$revision" + ;; + + linux) # correct to gnu/linux during the next big refactor + func_arith $current - $age + major=.$func_arith_result + versuffix="$major.$age.$revision" + ;; + + osf) + func_arith $current - $age + major=.$func_arith_result + versuffix=".$current.$age.$revision" + verstring="$current.$age.$revision" + + # Add in all the interfaces that we are compatible with. + loop=$age + while test "$loop" -ne 0; do + func_arith $current - $loop + iface=$func_arith_result + func_arith $loop - 1 + loop=$func_arith_result + verstring="$verstring:${iface}.0" + done + + # Make executables depend on our current version. + func_append verstring ":${current}.0" + ;; + + qnx) + major=".$current" + versuffix=".$current" + ;; + + sunos) + major=".$current" + versuffix=".$current.$revision" + ;; + + windows) + # Use '-' rather than '.', since we only want one + # extension on DOS 8.3 filesystems. + func_arith $current - $age + major=$func_arith_result + versuffix="-$major" + ;; + + *) + func_fatal_configuration "unknown library version type \`$version_type'" + ;; + esac + + # Clear the version info if we defaulted, and they specified a release. + if test -z "$vinfo" && test -n "$release"; then + major= + case $version_type in + darwin) + # we can't check for "0.0" in archive_cmds due to quoting + # problems, so we reset it completely + verstring= + ;; + *) + verstring="0.0" + ;; + esac + if test "$need_version" = no; then + versuffix= + else + versuffix=".0.0" + fi + fi + + # Remove version info from name if versioning should be avoided + if test "$avoid_version" = yes && test "$need_version" = no; then + major= + versuffix= + verstring="" + fi + + # Check to see if the archive will have undefined symbols. + if test "$allow_undefined" = yes; then + if test "$allow_undefined_flag" = unsupported; then + func_warning "undefined symbols not allowed in $host shared libraries" + build_libtool_libs=no + build_old_libs=yes + fi + else + # Don't allow undefined symbols. + allow_undefined_flag="$no_undefined_flag" + fi + + fi + + func_generate_dlsyms "$libname" "$libname" "yes" + func_append libobjs " $symfileobj" + test "X$libobjs" = "X " && libobjs= + + if test "$opt_mode" != relink; then + # Remove our outputs, but don't remove object files since they + # may have been created when compiling PIC objects. + removelist= + tempremovelist=`$ECHO "$output_objdir/*"` + for p in $tempremovelist; do + case $p in + *.$objext | *.gcno) + ;; + $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*) + if test "X$precious_files_regex" != "X"; then + if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1 + then + continue + fi + fi + func_append removelist " $p" + ;; + *) ;; + esac + done + test -n "$removelist" && \ + func_show_eval "${RM}r \$removelist" + fi + + # Now set the variables for building old libraries. + if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then + func_append oldlibs " $output_objdir/$libname.$libext" + + # Transform .lo files to .o files. + oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP` + fi + + # Eliminate all temporary directories. + #for path in $notinst_path; do + # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"` + # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"` + # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"` + #done + + if test -n "$xrpath"; then + # If the user specified any rpath flags, then add them. + temp_xrpath= + for libdir in $xrpath; do + func_replace_sysroot "$libdir" + func_append temp_xrpath " -R$func_replace_sysroot_result" + case "$finalize_rpath " in + *" $libdir "*) ;; + *) func_append finalize_rpath " $libdir" ;; + esac + done + if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then + dependency_libs="$temp_xrpath $dependency_libs" + fi + fi + + # Make sure dlfiles contains only unique files that won't be dlpreopened + old_dlfiles="$dlfiles" + dlfiles= + for lib in $old_dlfiles; do + case " $dlprefiles $dlfiles " in + *" $lib "*) ;; + *) func_append dlfiles " $lib" ;; + esac + done + + # Make sure dlprefiles contains only unique files + old_dlprefiles="$dlprefiles" + dlprefiles= + for lib in $old_dlprefiles; do + case "$dlprefiles " in + *" $lib "*) ;; + *) func_append dlprefiles " $lib" ;; + esac + done + + if test "$build_libtool_libs" = yes; then + if test -n "$rpath"; then + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*) + # these systems don't actually have a c library (as such)! + ;; + *-*-rhapsody* | *-*-darwin1.[012]) + # Rhapsody C library is in the System framework + func_append deplibs " System.ltframework" + ;; + *-*-netbsd*) + # Don't link with libc until the a.out ld.so is fixed. + ;; + *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*) + # Do not include libc due to us having libc/libc_r. + ;; + *-*-sco3.2v5* | *-*-sco5v6*) + # Causes problems with __ctype + ;; + *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*) + # Compiler inserts libc in the correct place for threads to work + ;; + *) + # Add libc to deplibs on all other systems if necessary. + if test "$build_libtool_need_lc" = "yes"; then + func_append deplibs " -lc" + fi + ;; + esac + fi + + # Transform deplibs into only deplibs that can be linked in shared. + name_save=$name + libname_save=$libname + release_save=$release + versuffix_save=$versuffix + major_save=$major + # I'm not sure if I'm treating the release correctly. I think + # release should show up in the -l (ie -lgmp5) so we don't want to + # add it in twice. Is that correct? + release="" + versuffix="" + major="" + newdeplibs= + droppeddeps=no + case $deplibs_check_method in + pass_all) + # Don't check for shared/static. Everything works. + # This might be a little naive. We might want to check + # whether the library exists or not. But this is on + # osf3 & osf4 and I'm not really sure... Just + # implementing what was already the behavior. + newdeplibs=$deplibs + ;; + test_compile) + # This code stresses the "libraries are programs" paradigm to its + # limits. Maybe even breaks it. We compile a program, linking it + # against the deplibs as a proxy for the library. Then we can check + # whether they linked in statically or dynamically with ldd. + $opt_dry_run || $RM conftest.c + cat > conftest.c </dev/null` + $nocaseglob + else + potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null` + fi + for potent_lib in $potential_libs; do + # Follow soft links. + if ls -lLd "$potent_lib" 2>/dev/null | + $GREP " -> " >/dev/null; then + continue + fi + # The statement above tries to avoid entering an + # endless loop below, in case of cyclic links. + # We might still enter an endless loop, since a link + # loop can be closed while we follow links, + # but so what? + potlib="$potent_lib" + while test -h "$potlib" 2>/dev/null; do + potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'` + case $potliblink in + [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";; + *) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";; + esac + done + if eval $file_magic_cmd \"\$potlib\" 2>/dev/null | + $SED -e 10q | + $EGREP "$file_magic_regex" > /dev/null; then + func_append newdeplibs " $a_deplib" + a_deplib="" + break 2 + fi + done + done + fi + if test -n "$a_deplib" ; then + droppeddeps=yes + echo + $ECHO "*** Warning: linker path does not have real file for library $a_deplib." + echo "*** I have the capability to make that library automatically link in when" + echo "*** you link to this library. But I can only do this if you have a" + echo "*** shared version of the library, which you do not appear to have" + echo "*** because I did check the linker path looking for a file starting" + if test -z "$potlib" ; then + $ECHO "*** with $libname but no candidates were found. (...for file magic test)" + else + $ECHO "*** with $libname and none of the candidates passed a file format test" + $ECHO "*** using a file magic. Last file checked: $potlib" + fi + fi + ;; + *) + # Add a -L argument. + func_append newdeplibs " $a_deplib" + ;; + esac + done # Gone through all deplibs. + ;; + match_pattern*) + set dummy $deplibs_check_method; shift + match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"` + for a_deplib in $deplibs; do + case $a_deplib in + -l*) + func_stripname -l '' "$a_deplib" + name=$func_stripname_result + if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then + case " $predeps $postdeps " in + *" $a_deplib "*) + func_append newdeplibs " $a_deplib" + a_deplib="" + ;; + esac + fi + if test -n "$a_deplib" ; then + libname=`eval "\\$ECHO \"$libname_spec\""` + for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do + potential_libs=`ls $i/$libname[.-]* 2>/dev/null` + for potent_lib in $potential_libs; do + potlib="$potent_lib" # see symlink-check above in file_magic test + if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \ + $EGREP "$match_pattern_regex" > /dev/null; then + func_append newdeplibs " $a_deplib" + a_deplib="" + break 2 + fi + done + done + fi + if test -n "$a_deplib" ; then + droppeddeps=yes + echo + $ECHO "*** Warning: linker path does not have real file for library $a_deplib." + echo "*** I have the capability to make that library automatically link in when" + echo "*** you link to this library. But I can only do this if you have a" + echo "*** shared version of the library, which you do not appear to have" + echo "*** because I did check the linker path looking for a file starting" + if test -z "$potlib" ; then + $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)" + else + $ECHO "*** with $libname and none of the candidates passed a file format test" + $ECHO "*** using a regex pattern. Last file checked: $potlib" + fi + fi + ;; + *) + # Add a -L argument. + func_append newdeplibs " $a_deplib" + ;; + esac + done # Gone through all deplibs. + ;; + none | unknown | *) + newdeplibs="" + tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'` + if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then + for i in $predeps $postdeps ; do + # can't use Xsed below, because $i might contain '/' + tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"` + done + fi + case $tmp_deplibs in + *[!\ \ ]*) + echo + if test "X$deplibs_check_method" = "Xnone"; then + echo "*** Warning: inter-library dependencies are not supported in this platform." + else + echo "*** Warning: inter-library dependencies are not known to be supported." + fi + echo "*** All declared inter-library dependencies are being dropped." + droppeddeps=yes + ;; + esac + ;; + esac + versuffix=$versuffix_save + major=$major_save + release=$release_save + libname=$libname_save + name=$name_save + + case $host in + *-*-rhapsody* | *-*-darwin1.[012]) + # On Rhapsody replace the C library with the System framework + newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'` + ;; + esac + + if test "$droppeddeps" = yes; then + if test "$module" = yes; then + echo + echo "*** Warning: libtool could not satisfy all declared inter-library" + $ECHO "*** dependencies of module $libname. Therefore, libtool will create" + echo "*** a static module, that should work as long as the dlopening" + echo "*** application is linked with the -dlopen flag." + if test -z "$global_symbol_pipe"; then + echo + echo "*** However, this would only work if libtool was able to extract symbol" + echo "*** lists from a program, using \`nm' or equivalent, but libtool could" + echo "*** not find such a program. So, this module is probably useless." + echo "*** \`nm' from GNU binutils and a full rebuild may help." + fi + if test "$build_old_libs" = no; then + oldlibs="$output_objdir/$libname.$libext" + build_libtool_libs=module + build_old_libs=yes + else + build_libtool_libs=no + fi + else + echo "*** The inter-library dependencies that have been dropped here will be" + echo "*** automatically added whenever a program is linked with this library" + echo "*** or is declared to -dlopen it." + + if test "$allow_undefined" = no; then + echo + echo "*** Since this library must not contain undefined symbols," + echo "*** because either the platform does not support them or" + echo "*** it was explicitly requested with -no-undefined," + echo "*** libtool will only create a static version of it." + if test "$build_old_libs" = no; then + oldlibs="$output_objdir/$libname.$libext" + build_libtool_libs=module + build_old_libs=yes + else + build_libtool_libs=no + fi + fi + fi + fi + # Done checking deplibs! + deplibs=$newdeplibs + fi + # Time to change all our "foo.ltframework" stuff back to "-framework foo" + case $host in + *-*-darwin*) + newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + ;; + esac + + # move library search paths that coincide with paths to not yet + # installed libraries to the beginning of the library search list + new_libs= + for path in $notinst_path; do + case " $new_libs " in + *" -L$path/$objdir "*) ;; + *) + case " $deplibs " in + *" -L$path/$objdir "*) + func_append new_libs " -L$path/$objdir" ;; + esac + ;; + esac + done + for deplib in $deplibs; do + case $deplib in + -L*) + case " $new_libs " in + *" $deplib "*) ;; + *) func_append new_libs " $deplib" ;; + esac + ;; + *) func_append new_libs " $deplib" ;; + esac + done + deplibs="$new_libs" + + # All the library-specific variables (install_libdir is set above). + library_names= + old_library= + dlname= + + # Test again, we may have decided not to build it any more + if test "$build_libtool_libs" = yes; then + # Remove ${wl} instances when linking with ld. + # FIXME: should test the right _cmds variable. + case $archive_cmds in + *\$LD\ *) wl= ;; + esac + if test "$hardcode_into_libs" = yes; then + # Hardcode the library paths + hardcode_libdirs= + dep_rpath= + rpath="$finalize_rpath" + test "$opt_mode" != relink && rpath="$compile_rpath$rpath" + for libdir in $rpath; do + if test -n "$hardcode_libdir_flag_spec"; then + if test -n "$hardcode_libdir_separator"; then + func_replace_sysroot "$libdir" + libdir=$func_replace_sysroot_result + if test -z "$hardcode_libdirs"; then + hardcode_libdirs="$libdir" + else + # Just accumulate the unique libdirs. + case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in + *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) + ;; + *) + func_append hardcode_libdirs "$hardcode_libdir_separator$libdir" + ;; + esac + fi + else + eval flag=\"$hardcode_libdir_flag_spec\" + func_append dep_rpath " $flag" + fi + elif test -n "$runpath_var"; then + case "$perm_rpath " in + *" $libdir "*) ;; + *) func_append perm_rpath " $libdir" ;; + esac + fi + done + # Substitute the hardcoded libdirs into the rpath. + if test -n "$hardcode_libdir_separator" && + test -n "$hardcode_libdirs"; then + libdir="$hardcode_libdirs" + eval "dep_rpath=\"$hardcode_libdir_flag_spec\"" + fi + if test -n "$runpath_var" && test -n "$perm_rpath"; then + # We should set the runpath_var. + rpath= + for dir in $perm_rpath; do + func_append rpath "$dir:" + done + eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var" + fi + test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs" + fi + + shlibpath="$finalize_shlibpath" + test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath" + if test -n "$shlibpath"; then + eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var" + fi + + # Get the real and link names of the library. + eval shared_ext=\"$shrext_cmds\" + eval library_names=\"$library_names_spec\" + set dummy $library_names + shift + realname="$1" + shift + + if test -n "$soname_spec"; then + eval soname=\"$soname_spec\" + else + soname="$realname" + fi + if test -z "$dlname"; then + dlname=$soname + fi + + lib="$output_objdir/$realname" + linknames= + for link + do + func_append linknames " $link" + done + + # Use standard objects if they are pic + test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP` + test "X$libobjs" = "X " && libobjs= + + delfiles= + if test -n "$export_symbols" && test -n "$include_expsyms"; then + $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp" + export_symbols="$output_objdir/$libname.uexp" + func_append delfiles " $export_symbols" + fi + + orig_export_symbols= + case $host_os in + cygwin* | mingw* | cegcc*) + if test -n "$export_symbols" && test -z "$export_symbols_regex"; then + # exporting using user supplied symfile + if test "x`$SED 1q $export_symbols`" != xEXPORTS; then + # and it's NOT already a .def file. Must figure out + # which of the given symbols are data symbols and tag + # them as such. So, trigger use of export_symbols_cmds. + # export_symbols gets reassigned inside the "prepare + # the list of exported symbols" if statement, so the + # include_expsyms logic still works. + orig_export_symbols="$export_symbols" + export_symbols= + always_export_symbols=yes + fi + fi + ;; + esac + + # Prepare the list of exported symbols + if test -z "$export_symbols"; then + if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then + func_verbose "generating symbol list for \`$libname.la'" + export_symbols="$output_objdir/$libname.exp" + $opt_dry_run || $RM $export_symbols + cmds=$export_symbols_cmds + save_ifs="$IFS"; IFS='~' + for cmd1 in $cmds; do + IFS="$save_ifs" + # Take the normal branch if the nm_file_list_spec branch + # doesn't work or if tool conversion is not needed. + case $nm_file_list_spec~$to_tool_file_cmd in + *~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*) + try_normal_branch=yes + eval cmd=\"$cmd1\" + func_len " $cmd" + len=$func_len_result + ;; + *) + try_normal_branch=no + ;; + esac + if test "$try_normal_branch" = yes \ + && { test "$len" -lt "$max_cmd_len" \ + || test "$max_cmd_len" -le -1; } + then + func_show_eval "$cmd" 'exit $?' + skipped_export=false + elif test -n "$nm_file_list_spec"; then + func_basename "$output" + output_la=$func_basename_result + save_libobjs=$libobjs + save_output=$output + output=${output_objdir}/${output_la}.nm + func_to_tool_file "$output" + libobjs=$nm_file_list_spec$func_to_tool_file_result + func_append delfiles " $output" + func_verbose "creating $NM input file list: $output" + for obj in $save_libobjs; do + func_to_tool_file "$obj" + $ECHO "$func_to_tool_file_result" + done > "$output" + eval cmd=\"$cmd1\" + func_show_eval "$cmd" 'exit $?' + output=$save_output + libobjs=$save_libobjs + skipped_export=false + else + # The command line is too long to execute in one step. + func_verbose "using reloadable object file for export list..." + skipped_export=: + # Break out early, otherwise skipped_export may be + # set to false by a later but shorter cmd. + break + fi + done + IFS="$save_ifs" + if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then + func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"' + func_show_eval '$MV "${export_symbols}T" "$export_symbols"' + fi + fi + fi + + if test -n "$export_symbols" && test -n "$include_expsyms"; then + tmp_export_symbols="$export_symbols" + test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols" + $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"' + fi + + if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then + # The given exports_symbols file has to be filtered, so filter it. + func_verbose "filter symbol list for \`$libname.la' to tag DATA exports" + # FIXME: $output_objdir/$libname.filter potentially contains lots of + # 's' commands which not all seds can handle. GNU sed should be fine + # though. Also, the filter scales superlinearly with the number of + # global variables. join(1) would be nice here, but unfortunately + # isn't a blessed tool. + $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter + func_append delfiles " $export_symbols $output_objdir/$libname.filter" + export_symbols=$output_objdir/$libname.def + $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols + fi + + tmp_deplibs= + for test_deplib in $deplibs; do + case " $convenience " in + *" $test_deplib "*) ;; + *) + func_append tmp_deplibs " $test_deplib" + ;; + esac + done + deplibs="$tmp_deplibs" + + if test -n "$convenience"; then + if test -n "$whole_archive_flag_spec" && + test "$compiler_needs_object" = yes && + test -z "$libobjs"; then + # extract the archives, so we have objects to list. + # TODO: could optimize this to just extract one archive. + whole_archive_flag_spec= + fi + if test -n "$whole_archive_flag_spec"; then + save_libobjs=$libobjs + eval libobjs=\"\$libobjs $whole_archive_flag_spec\" + test "X$libobjs" = "X " && libobjs= + else + gentop="$output_objdir/${outputname}x" + func_append generated " $gentop" + + func_extract_archives $gentop $convenience + func_append libobjs " $func_extract_archives_result" + test "X$libobjs" = "X " && libobjs= + fi + fi + + if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then + eval flag=\"$thread_safe_flag_spec\" + func_append linker_flags " $flag" + fi + + # Make a backup of the uninstalled library when relinking + if test "$opt_mode" = relink; then + $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $? + fi + + # Do each of the archive commands. + if test "$module" = yes && test -n "$module_cmds" ; then + if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then + eval test_cmds=\"$module_expsym_cmds\" + cmds=$module_expsym_cmds + else + eval test_cmds=\"$module_cmds\" + cmds=$module_cmds + fi + else + if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then + eval test_cmds=\"$archive_expsym_cmds\" + cmds=$archive_expsym_cmds + else + eval test_cmds=\"$archive_cmds\" + cmds=$archive_cmds + fi + fi + + if test "X$skipped_export" != "X:" && + func_len " $test_cmds" && + len=$func_len_result && + test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then + : + else + # The command line is too long to link in one step, link piecewise + # or, if using GNU ld and skipped_export is not :, use a linker + # script. + + # Save the value of $output and $libobjs because we want to + # use them later. If we have whole_archive_flag_spec, we + # want to use save_libobjs as it was before + # whole_archive_flag_spec was expanded, because we can't + # assume the linker understands whole_archive_flag_spec. + # This may have to be revisited, in case too many + # convenience libraries get linked in and end up exceeding + # the spec. + if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then + save_libobjs=$libobjs + fi + save_output=$output + func_basename "$output" + output_la=$func_basename_result + + # Clear the reloadable object creation command queue and + # initialize k to one. + test_cmds= + concat_cmds= + objlist= + last_robj= + k=1 + + if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then + output=${output_objdir}/${output_la}.lnkscript + func_verbose "creating GNU ld script: $output" + echo 'INPUT (' > $output + for obj in $save_libobjs + do + func_to_tool_file "$obj" + $ECHO "$func_to_tool_file_result" >> $output + done + echo ')' >> $output + func_append delfiles " $output" + func_to_tool_file "$output" + output=$func_to_tool_file_result + elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then + output=${output_objdir}/${output_la}.lnk + func_verbose "creating linker input file list: $output" + : > $output + set x $save_libobjs + shift + firstobj= + if test "$compiler_needs_object" = yes; then + firstobj="$1 " + shift + fi + for obj + do + func_to_tool_file "$obj" + $ECHO "$func_to_tool_file_result" >> $output + done + func_append delfiles " $output" + func_to_tool_file "$output" + output=$firstobj\"$file_list_spec$func_to_tool_file_result\" + else + if test -n "$save_libobjs"; then + func_verbose "creating reloadable object files..." + output=$output_objdir/$output_la-${k}.$objext + eval test_cmds=\"$reload_cmds\" + func_len " $test_cmds" + len0=$func_len_result + len=$len0 + + # Loop over the list of objects to be linked. + for obj in $save_libobjs + do + func_len " $obj" + func_arith $len + $func_len_result + len=$func_arith_result + if test "X$objlist" = X || + test "$len" -lt "$max_cmd_len"; then + func_append objlist " $obj" + else + # The command $test_cmds is almost too long, add a + # command to the queue. + if test "$k" -eq 1 ; then + # The first file doesn't have a previous command to add. + reload_objs=$objlist + eval concat_cmds=\"$reload_cmds\" + else + # All subsequent reloadable object files will link in + # the last one created. + reload_objs="$objlist $last_robj" + eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\" + fi + last_robj=$output_objdir/$output_la-${k}.$objext + func_arith $k + 1 + k=$func_arith_result + output=$output_objdir/$output_la-${k}.$objext + objlist=" $obj" + func_len " $last_robj" + func_arith $len0 + $func_len_result + len=$func_arith_result + fi + done + # Handle the remaining objects by creating one last + # reloadable object file. All subsequent reloadable object + # files will link in the last one created. + test -z "$concat_cmds" || concat_cmds=$concat_cmds~ + reload_objs="$objlist $last_robj" + eval concat_cmds=\"\${concat_cmds}$reload_cmds\" + if test -n "$last_robj"; then + eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\" + fi + func_append delfiles " $output" + + else + output= + fi + + if ${skipped_export-false}; then + func_verbose "generating symbol list for \`$libname.la'" + export_symbols="$output_objdir/$libname.exp" + $opt_dry_run || $RM $export_symbols + libobjs=$output + # Append the command to create the export file. + test -z "$concat_cmds" || concat_cmds=$concat_cmds~ + eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\" + if test -n "$last_robj"; then + eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\" + fi + fi + + test -n "$save_libobjs" && + func_verbose "creating a temporary reloadable object file: $output" + + # Loop through the commands generated above and execute them. + save_ifs="$IFS"; IFS='~' + for cmd in $concat_cmds; do + IFS="$save_ifs" + $opt_silent || { + func_quote_for_expand "$cmd" + eval "func_echo $func_quote_for_expand_result" + } + $opt_dry_run || eval "$cmd" || { + lt_exit=$? + + # Restore the uninstalled library and exit + if test "$opt_mode" = relink; then + ( cd "$output_objdir" && \ + $RM "${realname}T" && \ + $MV "${realname}U" "$realname" ) + fi + + exit $lt_exit + } + done + IFS="$save_ifs" + + if test -n "$export_symbols_regex" && ${skipped_export-false}; then + func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"' + func_show_eval '$MV "${export_symbols}T" "$export_symbols"' + fi + fi + + if ${skipped_export-false}; then + if test -n "$export_symbols" && test -n "$include_expsyms"; then + tmp_export_symbols="$export_symbols" + test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols" + $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"' + fi + + if test -n "$orig_export_symbols"; then + # The given exports_symbols file has to be filtered, so filter it. + func_verbose "filter symbol list for \`$libname.la' to tag DATA exports" + # FIXME: $output_objdir/$libname.filter potentially contains lots of + # 's' commands which not all seds can handle. GNU sed should be fine + # though. Also, the filter scales superlinearly with the number of + # global variables. join(1) would be nice here, but unfortunately + # isn't a blessed tool. + $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter + func_append delfiles " $export_symbols $output_objdir/$libname.filter" + export_symbols=$output_objdir/$libname.def + $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols + fi + fi + + libobjs=$output + # Restore the value of output. + output=$save_output + + if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then + eval libobjs=\"\$libobjs $whole_archive_flag_spec\" + test "X$libobjs" = "X " && libobjs= + fi + # Expand the library linking commands again to reset the + # value of $libobjs for piecewise linking. + + # Do each of the archive commands. + if test "$module" = yes && test -n "$module_cmds" ; then + if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then + cmds=$module_expsym_cmds + else + cmds=$module_cmds + fi + else + if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then + cmds=$archive_expsym_cmds + else + cmds=$archive_cmds + fi + fi + fi + + if test -n "$delfiles"; then + # Append the command to remove temporary files to $cmds. + eval cmds=\"\$cmds~\$RM $delfiles\" + fi + + # Add any objects from preloaded convenience libraries + if test -n "$dlprefiles"; then + gentop="$output_objdir/${outputname}x" + func_append generated " $gentop" + + func_extract_archives $gentop $dlprefiles + func_append libobjs " $func_extract_archives_result" + test "X$libobjs" = "X " && libobjs= + fi + + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $opt_silent || { + func_quote_for_expand "$cmd" + eval "func_echo $func_quote_for_expand_result" + } + $opt_dry_run || eval "$cmd" || { + lt_exit=$? + + # Restore the uninstalled library and exit + if test "$opt_mode" = relink; then + ( cd "$output_objdir" && \ + $RM "${realname}T" && \ + $MV "${realname}U" "$realname" ) + fi + + exit $lt_exit + } + done + IFS="$save_ifs" + + # Restore the uninstalled library and exit + if test "$opt_mode" = relink; then + $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $? + + if test -n "$convenience"; then + if test -z "$whole_archive_flag_spec"; then + func_show_eval '${RM}r "$gentop"' + fi + fi + + exit $EXIT_SUCCESS + fi + + # Create links to the real library. + for linkname in $linknames; do + if test "$realname" != "$linkname"; then + func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?' + fi + done + + # If -module or -export-dynamic was specified, set the dlname. + if test "$module" = yes || test "$export_dynamic" = yes; then + # On all known operating systems, these are identical. + dlname="$soname" + fi + fi + ;; + + obj) + if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then + func_warning "\`-dlopen' is ignored for objects" + fi + + case " $deplibs" in + *\ -l* | *\ -L*) + func_warning "\`-l' and \`-L' are ignored for objects" ;; + esac + + test -n "$rpath" && \ + func_warning "\`-rpath' is ignored for objects" + + test -n "$xrpath" && \ + func_warning "\`-R' is ignored for objects" + + test -n "$vinfo" && \ + func_warning "\`-version-info' is ignored for objects" + + test -n "$release" && \ + func_warning "\`-release' is ignored for objects" + + case $output in + *.lo) + test -n "$objs$old_deplibs" && \ + func_fatal_error "cannot build library object \`$output' from non-libtool objects" + + libobj=$output + func_lo2o "$libobj" + obj=$func_lo2o_result + ;; + *) + libobj= + obj="$output" + ;; + esac + + # Delete the old objects. + $opt_dry_run || $RM $obj $libobj + + # Objects from convenience libraries. This assumes + # single-version convenience libraries. Whenever we create + # different ones for PIC/non-PIC, this we'll have to duplicate + # the extraction. + reload_conv_objs= + gentop= + # reload_cmds runs $LD directly, so let us get rid of + # -Wl from whole_archive_flag_spec and hope we can get by with + # turning comma into space.. + wl= + + if test -n "$convenience"; then + if test -n "$whole_archive_flag_spec"; then + eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\" + reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'` + else + gentop="$output_objdir/${obj}x" + func_append generated " $gentop" + + func_extract_archives $gentop $convenience + reload_conv_objs="$reload_objs $func_extract_archives_result" + fi + fi + + # If we're not building shared, we need to use non_pic_objs + test "$build_libtool_libs" != yes && libobjs="$non_pic_objects" + + # Create the old-style object. + reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test + + output="$obj" + func_execute_cmds "$reload_cmds" 'exit $?' + + # Exit if we aren't doing a library object file. + if test -z "$libobj"; then + if test -n "$gentop"; then + func_show_eval '${RM}r "$gentop"' + fi + + exit $EXIT_SUCCESS + fi + + if test "$build_libtool_libs" != yes; then + if test -n "$gentop"; then + func_show_eval '${RM}r "$gentop"' + fi + + # Create an invalid libtool object if no PIC, so that we don't + # accidentally link it into a program. + # $show "echo timestamp > $libobj" + # $opt_dry_run || eval "echo timestamp > $libobj" || exit $? + exit $EXIT_SUCCESS + fi + + if test -n "$pic_flag" || test "$pic_mode" != default; then + # Only do commands if we really have different PIC objects. + reload_objs="$libobjs $reload_conv_objs" + output="$libobj" + func_execute_cmds "$reload_cmds" 'exit $?' + fi + + if test -n "$gentop"; then + func_show_eval '${RM}r "$gentop"' + fi + + exit $EXIT_SUCCESS + ;; + + prog) + case $host in + *cygwin*) func_stripname '' '.exe' "$output" + output=$func_stripname_result.exe;; + esac + test -n "$vinfo" && \ + func_warning "\`-version-info' is ignored for programs" + + test -n "$release" && \ + func_warning "\`-release' is ignored for programs" + + test "$preload" = yes \ + && test "$dlopen_support" = unknown \ + && test "$dlopen_self" = unknown \ + && test "$dlopen_self_static" = unknown && \ + func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support." + + case $host in + *-*-rhapsody* | *-*-darwin1.[012]) + # On Rhapsody replace the C library is the System framework + compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'` + finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'` + ;; + esac + + case $host in + *-*-darwin*) + # Don't allow lazy linking, it breaks C++ global constructors + # But is supposedly fixed on 10.4 or later (yay!). + if test "$tagname" = CXX ; then + case ${MACOSX_DEPLOYMENT_TARGET-10.0} in + 10.[0123]) + func_append compile_command " ${wl}-bind_at_load" + func_append finalize_command " ${wl}-bind_at_load" + ;; + esac + fi + # Time to change all our "foo.ltframework" stuff back to "-framework foo" + compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + ;; + esac + + + # move library search paths that coincide with paths to not yet + # installed libraries to the beginning of the library search list + new_libs= + for path in $notinst_path; do + case " $new_libs " in + *" -L$path/$objdir "*) ;; + *) + case " $compile_deplibs " in + *" -L$path/$objdir "*) + func_append new_libs " -L$path/$objdir" ;; + esac + ;; + esac + done + for deplib in $compile_deplibs; do + case $deplib in + -L*) + case " $new_libs " in + *" $deplib "*) ;; + *) func_append new_libs " $deplib" ;; + esac + ;; + *) func_append new_libs " $deplib" ;; + esac + done + compile_deplibs="$new_libs" + + + func_append compile_command " $compile_deplibs" + func_append finalize_command " $finalize_deplibs" + + if test -n "$rpath$xrpath"; then + # If the user specified any rpath flags, then add them. + for libdir in $rpath $xrpath; do + # This is the magic to use -rpath. + case "$finalize_rpath " in + *" $libdir "*) ;; + *) func_append finalize_rpath " $libdir" ;; + esac + done + fi + + # Now hardcode the library paths + rpath= + hardcode_libdirs= + for libdir in $compile_rpath $finalize_rpath; do + if test -n "$hardcode_libdir_flag_spec"; then + if test -n "$hardcode_libdir_separator"; then + if test -z "$hardcode_libdirs"; then + hardcode_libdirs="$libdir" + else + # Just accumulate the unique libdirs. + case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in + *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) + ;; + *) + func_append hardcode_libdirs "$hardcode_libdir_separator$libdir" + ;; + esac + fi + else + eval flag=\"$hardcode_libdir_flag_spec\" + func_append rpath " $flag" + fi + elif test -n "$runpath_var"; then + case "$perm_rpath " in + *" $libdir "*) ;; + *) func_append perm_rpath " $libdir" ;; + esac + fi + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) + testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'` + case :$dllsearchpath: in + *":$libdir:"*) ;; + ::) dllsearchpath=$libdir;; + *) func_append dllsearchpath ":$libdir";; + esac + case :$dllsearchpath: in + *":$testbindir:"*) ;; + ::) dllsearchpath=$testbindir;; + *) func_append dllsearchpath ":$testbindir";; + esac + ;; + esac + done + # Substitute the hardcoded libdirs into the rpath. + if test -n "$hardcode_libdir_separator" && + test -n "$hardcode_libdirs"; then + libdir="$hardcode_libdirs" + eval rpath=\" $hardcode_libdir_flag_spec\" + fi + compile_rpath="$rpath" + + rpath= + hardcode_libdirs= + for libdir in $finalize_rpath; do + if test -n "$hardcode_libdir_flag_spec"; then + if test -n "$hardcode_libdir_separator"; then + if test -z "$hardcode_libdirs"; then + hardcode_libdirs="$libdir" + else + # Just accumulate the unique libdirs. + case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in + *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) + ;; + *) + func_append hardcode_libdirs "$hardcode_libdir_separator$libdir" + ;; + esac + fi + else + eval flag=\"$hardcode_libdir_flag_spec\" + func_append rpath " $flag" + fi + elif test -n "$runpath_var"; then + case "$finalize_perm_rpath " in + *" $libdir "*) ;; + *) func_append finalize_perm_rpath " $libdir" ;; + esac + fi + done + # Substitute the hardcoded libdirs into the rpath. + if test -n "$hardcode_libdir_separator" && + test -n "$hardcode_libdirs"; then + libdir="$hardcode_libdirs" + eval rpath=\" $hardcode_libdir_flag_spec\" + fi + finalize_rpath="$rpath" + + if test -n "$libobjs" && test "$build_old_libs" = yes; then + # Transform all the library objects into standard objects. + compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP` + finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP` + fi + + func_generate_dlsyms "$outputname" "@PROGRAM@" "no" + + # template prelinking step + if test -n "$prelink_cmds"; then + func_execute_cmds "$prelink_cmds" 'exit $?' + fi + + wrappers_required=yes + case $host in + *cegcc* | *mingw32ce*) + # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway. + wrappers_required=no + ;; + *cygwin* | *mingw* ) + if test "$build_libtool_libs" != yes; then + wrappers_required=no + fi + ;; + *) + if test "$need_relink" = no || test "$build_libtool_libs" != yes; then + wrappers_required=no + fi + ;; + esac + if test "$wrappers_required" = no; then + # Replace the output file specification. + compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'` + link_command="$compile_command$compile_rpath" + + # We have no uninstalled library dependencies, so finalize right now. + exit_status=0 + func_show_eval "$link_command" 'exit_status=$?' + + if test -n "$postlink_cmds"; then + func_to_tool_file "$output" + postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'` + func_execute_cmds "$postlink_cmds" 'exit $?' + fi + + # Delete the generated files. + if test -f "$output_objdir/${outputname}S.${objext}"; then + func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"' + fi + + exit $exit_status + fi + + if test -n "$compile_shlibpath$finalize_shlibpath"; then + compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command" + fi + if test -n "$finalize_shlibpath"; then + finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command" + fi + + compile_var= + finalize_var= + if test -n "$runpath_var"; then + if test -n "$perm_rpath"; then + # We should set the runpath_var. + rpath= + for dir in $perm_rpath; do + func_append rpath "$dir:" + done + compile_var="$runpath_var=\"$rpath\$$runpath_var\" " + fi + if test -n "$finalize_perm_rpath"; then + # We should set the runpath_var. + rpath= + for dir in $finalize_perm_rpath; do + func_append rpath "$dir:" + done + finalize_var="$runpath_var=\"$rpath\$$runpath_var\" " + fi + fi + + if test "$no_install" = yes; then + # We don't need to create a wrapper script. + link_command="$compile_var$compile_command$compile_rpath" + # Replace the output file specification. + link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'` + # Delete the old output file. + $opt_dry_run || $RM $output + # Link the executable and exit + func_show_eval "$link_command" 'exit $?' + + if test -n "$postlink_cmds"; then + func_to_tool_file "$output" + postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'` + func_execute_cmds "$postlink_cmds" 'exit $?' + fi + + exit $EXIT_SUCCESS + fi + + if test "$hardcode_action" = relink; then + # Fast installation is not supported + link_command="$compile_var$compile_command$compile_rpath" + relink_command="$finalize_var$finalize_command$finalize_rpath" + + func_warning "this platform does not like uninstalled shared libraries" + func_warning "\`$output' will be relinked during installation" + else + if test "$fast_install" != no; then + link_command="$finalize_var$compile_command$finalize_rpath" + if test "$fast_install" = yes; then + relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'` + else + # fast_install is set to needless + relink_command= + fi + else + link_command="$compile_var$compile_command$compile_rpath" + relink_command="$finalize_var$finalize_command$finalize_rpath" + fi + fi + + # Replace the output file specification. + link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'` + + # Delete the old output files. + $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname + + func_show_eval "$link_command" 'exit $?' + + if test -n "$postlink_cmds"; then + func_to_tool_file "$output_objdir/$outputname" + postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'` + func_execute_cmds "$postlink_cmds" 'exit $?' + fi + + # Now create the wrapper script. + func_verbose "creating $output" + + # Quote the relink command for shipping. + if test -n "$relink_command"; then + # Preserve any variables that may affect compiler behavior + for var in $variables_saved_for_relink; do + if eval test -z \"\${$var+set}\"; then + relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command" + elif eval var_value=\$$var; test -z "$var_value"; then + relink_command="$var=; export $var; $relink_command" + else + func_quote_for_eval "$var_value" + relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command" + fi + done + relink_command="(cd `pwd`; $relink_command)" + relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"` + fi + + # Only actually do things if not in dry run mode. + $opt_dry_run || { + # win32 will think the script is a binary if it has + # a .exe suffix, so we strip it off here. + case $output in + *.exe) func_stripname '' '.exe' "$output" + output=$func_stripname_result ;; + esac + # test for cygwin because mv fails w/o .exe extensions + case $host in + *cygwin*) + exeext=.exe + func_stripname '' '.exe' "$outputname" + outputname=$func_stripname_result ;; + *) exeext= ;; + esac + case $host in + *cygwin* | *mingw* ) + func_dirname_and_basename "$output" "" "." + output_name=$func_basename_result + output_path=$func_dirname_result + cwrappersource="$output_path/$objdir/lt-$output_name.c" + cwrapper="$output_path/$output_name.exe" + $RM $cwrappersource $cwrapper + trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15 + + func_emit_cwrapperexe_src > $cwrappersource + + # The wrapper executable is built using the $host compiler, + # because it contains $host paths and files. If cross- + # compiling, it, like the target executable, must be + # executed on the $host or under an emulation environment. + $opt_dry_run || { + $LTCC $LTCFLAGS -o $cwrapper $cwrappersource + $STRIP $cwrapper + } + + # Now, create the wrapper script for func_source use: + func_ltwrapper_scriptname $cwrapper + $RM $func_ltwrapper_scriptname_result + trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15 + $opt_dry_run || { + # note: this script will not be executed, so do not chmod. + if test "x$build" = "x$host" ; then + $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result + else + func_emit_wrapper no > $func_ltwrapper_scriptname_result + fi + } + ;; + * ) + $RM $output + trap "$RM $output; exit $EXIT_FAILURE" 1 2 15 + + func_emit_wrapper no > $output + chmod +x $output + ;; + esac + } + exit $EXIT_SUCCESS + ;; + esac + + # See if we need to build an old-fashioned archive. + for oldlib in $oldlibs; do + + if test "$build_libtool_libs" = convenience; then + oldobjs="$libobjs_save $symfileobj" + addlibs="$convenience" + build_libtool_libs=no + else + if test "$build_libtool_libs" = module; then + oldobjs="$libobjs_save" + build_libtool_libs=no + else + oldobjs="$old_deplibs $non_pic_objects" + if test "$preload" = yes && test -f "$symfileobj"; then + func_append oldobjs " $symfileobj" + fi + fi + addlibs="$old_convenience" + fi + + if test -n "$addlibs"; then + gentop="$output_objdir/${outputname}x" + func_append generated " $gentop" + + func_extract_archives $gentop $addlibs + func_append oldobjs " $func_extract_archives_result" + fi + + # Do each command in the archive commands. + if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then + cmds=$old_archive_from_new_cmds + else + + # Add any objects from preloaded convenience libraries + if test -n "$dlprefiles"; then + gentop="$output_objdir/${outputname}x" + func_append generated " $gentop" + + func_extract_archives $gentop $dlprefiles + func_append oldobjs " $func_extract_archives_result" + fi + + # POSIX demands no paths to be encoded in archives. We have + # to avoid creating archives with duplicate basenames if we + # might have to extract them afterwards, e.g., when creating a + # static archive out of a convenience library, or when linking + # the entirety of a libtool archive into another (currently + # not supported by libtool). + if (for obj in $oldobjs + do + func_basename "$obj" + $ECHO "$func_basename_result" + done | sort | sort -uc >/dev/null 2>&1); then + : + else + echo "copying selected object files to avoid basename conflicts..." + gentop="$output_objdir/${outputname}x" + func_append generated " $gentop" + func_mkdir_p "$gentop" + save_oldobjs=$oldobjs + oldobjs= + counter=1 + for obj in $save_oldobjs + do + func_basename "$obj" + objbase="$func_basename_result" + case " $oldobjs " in + " ") oldobjs=$obj ;; + *[\ /]"$objbase "*) + while :; do + # Make sure we don't pick an alternate name that also + # overlaps. + newobj=lt$counter-$objbase + func_arith $counter + 1 + counter=$func_arith_result + case " $oldobjs " in + *[\ /]"$newobj "*) ;; + *) if test ! -f "$gentop/$newobj"; then break; fi ;; + esac + done + func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj" + func_append oldobjs " $gentop/$newobj" + ;; + *) func_append oldobjs " $obj" ;; + esac + done + fi + func_to_tool_file "$oldlib" func_convert_file_msys_to_w32 + tool_oldlib=$func_to_tool_file_result + eval cmds=\"$old_archive_cmds\" + + func_len " $cmds" + len=$func_len_result + if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then + cmds=$old_archive_cmds + elif test -n "$archiver_list_spec"; then + func_verbose "using command file archive linking..." + for obj in $oldobjs + do + func_to_tool_file "$obj" + $ECHO "$func_to_tool_file_result" + done > $output_objdir/$libname.libcmd + func_to_tool_file "$output_objdir/$libname.libcmd" + oldobjs=" $archiver_list_spec$func_to_tool_file_result" + cmds=$old_archive_cmds + else + # the command line is too long to link in one step, link in parts + func_verbose "using piecewise archive linking..." + save_RANLIB=$RANLIB + RANLIB=: + objlist= + concat_cmds= + save_oldobjs=$oldobjs + oldobjs= + # Is there a better way of finding the last object in the list? + for obj in $save_oldobjs + do + last_oldobj=$obj + done + eval test_cmds=\"$old_archive_cmds\" + func_len " $test_cmds" + len0=$func_len_result + len=$len0 + for obj in $save_oldobjs + do + func_len " $obj" + func_arith $len + $func_len_result + len=$func_arith_result + func_append objlist " $obj" + if test "$len" -lt "$max_cmd_len"; then + : + else + # the above command should be used before it gets too long + oldobjs=$objlist + if test "$obj" = "$last_oldobj" ; then + RANLIB=$save_RANLIB + fi + test -z "$concat_cmds" || concat_cmds=$concat_cmds~ + eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\" + objlist= + len=$len0 + fi + done + RANLIB=$save_RANLIB + oldobjs=$objlist + if test "X$oldobjs" = "X" ; then + eval cmds=\"\$concat_cmds\" + else + eval cmds=\"\$concat_cmds~\$old_archive_cmds\" + fi + fi + fi + func_execute_cmds "$cmds" 'exit $?' + done + + test -n "$generated" && \ + func_show_eval "${RM}r$generated" + + # Now create the libtool archive. + case $output in + *.la) + old_library= + test "$build_old_libs" = yes && old_library="$libname.$libext" + func_verbose "creating $output" + + # Preserve any variables that may affect compiler behavior + for var in $variables_saved_for_relink; do + if eval test -z \"\${$var+set}\"; then + relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command" + elif eval var_value=\$$var; test -z "$var_value"; then + relink_command="$var=; export $var; $relink_command" + else + func_quote_for_eval "$var_value" + relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command" + fi + done + # Quote the link command for shipping. + relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)" + relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"` + if test "$hardcode_automatic" = yes ; then + relink_command= + fi + + # Only create the output if not a dry run. + $opt_dry_run || { + for installed in no yes; do + if test "$installed" = yes; then + if test -z "$install_libdir"; then + break + fi + output="$output_objdir/$outputname"i + # Replace all uninstalled libtool libraries with the installed ones + newdependency_libs= + for deplib in $dependency_libs; do + case $deplib in + *.la) + func_basename "$deplib" + name="$func_basename_result" + func_resolve_sysroot "$deplib" + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result` + test -z "$libdir" && \ + func_fatal_error "\`$deplib' is not a valid libtool archive" + func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name" + ;; + -L*) + func_stripname -L '' "$deplib" + func_replace_sysroot "$func_stripname_result" + func_append newdependency_libs " -L$func_replace_sysroot_result" + ;; + -R*) + func_stripname -R '' "$deplib" + func_replace_sysroot "$func_stripname_result" + func_append newdependency_libs " -R$func_replace_sysroot_result" + ;; + *) func_append newdependency_libs " $deplib" ;; + esac + done + dependency_libs="$newdependency_libs" + newdlfiles= + + for lib in $dlfiles; do + case $lib in + *.la) + func_basename "$lib" + name="$func_basename_result" + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib` + test -z "$libdir" && \ + func_fatal_error "\`$lib' is not a valid libtool archive" + func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name" + ;; + *) func_append newdlfiles " $lib" ;; + esac + done + dlfiles="$newdlfiles" + newdlprefiles= + for lib in $dlprefiles; do + case $lib in + *.la) + # Only pass preopened files to the pseudo-archive (for + # eventual linking with the app. that links it) if we + # didn't already link the preopened objects directly into + # the library: + func_basename "$lib" + name="$func_basename_result" + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib` + test -z "$libdir" && \ + func_fatal_error "\`$lib' is not a valid libtool archive" + func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name" + ;; + esac + done + dlprefiles="$newdlprefiles" + else + newdlfiles= + for lib in $dlfiles; do + case $lib in + [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;; + *) abs=`pwd`"/$lib" ;; + esac + func_append newdlfiles " $abs" + done + dlfiles="$newdlfiles" + newdlprefiles= + for lib in $dlprefiles; do + case $lib in + [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;; + *) abs=`pwd`"/$lib" ;; + esac + func_append newdlprefiles " $abs" + done + dlprefiles="$newdlprefiles" + fi + $RM $output + # place dlname in correct position for cygwin + # In fact, it would be nice if we could use this code for all target + # systems that can't hard-code library paths into their executables + # and that have no shared library path variable independent of PATH, + # but it turns out we can't easily determine that from inspecting + # libtool variables, so we have to hard-code the OSs to which it + # applies here; at the moment, that means platforms that use the PE + # object format with DLL files. See the long comment at the top of + # tests/bindir.at for full details. + tdlname=$dlname + case $host,$output,$installed,$module,$dlname in + *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) + # If a -bindir argument was supplied, place the dll there. + if test "x$bindir" != x ; + then + func_relative_path "$install_libdir" "$bindir" + tdlname=$func_relative_path_result$dlname + else + # Otherwise fall back on heuristic. + tdlname=../bin/$dlname + fi + ;; + esac + $ECHO > $output "\ +# $outputname - a libtool library file +# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION +# +# Please DO NOT delete this file! +# It is necessary for linking the library. + +# The name that we can dlopen(3). +dlname='$tdlname' + +# Names of this library. +library_names='$library_names' + +# The name of the static archive. +old_library='$old_library' + +# Linker flags that can not go in dependency_libs. +inherited_linker_flags='$new_inherited_linker_flags' + +# Libraries that this one depends upon. +dependency_libs='$dependency_libs' + +# Names of additional weak libraries provided by this library +weak_library_names='$weak_libs' + +# Version information for $libname. +current=$current +age=$age +revision=$revision + +# Is this an already installed library? +installed=$installed + +# Should we warn about portability when linking against -modules? +shouldnotlink=$module + +# Files to dlopen/dlpreopen +dlopen='$dlfiles' +dlpreopen='$dlprefiles' + +# Directory that this library needs to be installed in: +libdir='$install_libdir'" + if test "$installed" = no && test "$need_relink" = yes; then + $ECHO >> $output "\ +relink_command=\"$relink_command\"" + fi + done + } + + # Do a symbolic link so that the libtool archive can be found in + # LD_LIBRARY_PATH before the program is installed. + func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?' + ;; + esac + exit $EXIT_SUCCESS +} + +{ test "$opt_mode" = link || test "$opt_mode" = relink; } && + func_mode_link ${1+"$@"} + + +# func_mode_uninstall arg... +func_mode_uninstall () +{ + $opt_debug + RM="$nonopt" + files= + rmforce= + exit_status=0 + + # This variable tells wrapper scripts just to set variables rather + # than running their programs. + libtool_install_magic="$magic" + + for arg + do + case $arg in + -f) func_append RM " $arg"; rmforce=yes ;; + -*) func_append RM " $arg" ;; + *) func_append files " $arg" ;; + esac + done + + test -z "$RM" && \ + func_fatal_help "you must specify an RM program" + + rmdirs= + + for file in $files; do + func_dirname "$file" "" "." + dir="$func_dirname_result" + if test "X$dir" = X.; then + odir="$objdir" + else + odir="$dir/$objdir" + fi + func_basename "$file" + name="$func_basename_result" + test "$opt_mode" = uninstall && odir="$dir" + + # Remember odir for removal later, being careful to avoid duplicates + if test "$opt_mode" = clean; then + case " $rmdirs " in + *" $odir "*) ;; + *) func_append rmdirs " $odir" ;; + esac + fi + + # Don't error if the file doesn't exist and rm -f was used. + if { test -L "$file"; } >/dev/null 2>&1 || + { test -h "$file"; } >/dev/null 2>&1 || + test -f "$file"; then + : + elif test -d "$file"; then + exit_status=1 + continue + elif test "$rmforce" = yes; then + continue + fi + + rmfiles="$file" + + case $name in + *.la) + # Possibly a libtool archive, so verify it. + if func_lalib_p "$file"; then + func_source $dir/$name + + # Delete the libtool libraries and symlinks. + for n in $library_names; do + func_append rmfiles " $odir/$n" + done + test -n "$old_library" && func_append rmfiles " $odir/$old_library" + + case "$opt_mode" in + clean) + case " $library_names " in + *" $dlname "*) ;; + *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;; + esac + test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i" + ;; + uninstall) + if test -n "$library_names"; then + # Do each command in the postuninstall commands. + func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1' + fi + + if test -n "$old_library"; then + # Do each command in the old_postuninstall commands. + func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1' + fi + # FIXME: should reinstall the best remaining shared library. + ;; + esac + fi + ;; + + *.lo) + # Possibly a libtool object, so verify it. + if func_lalib_p "$file"; then + + # Read the .lo file + func_source $dir/$name + + # Add PIC object to the list of files to remove. + if test -n "$pic_object" && + test "$pic_object" != none; then + func_append rmfiles " $dir/$pic_object" + fi + + # Add non-PIC object to the list of files to remove. + if test -n "$non_pic_object" && + test "$non_pic_object" != none; then + func_append rmfiles " $dir/$non_pic_object" + fi + fi + ;; + + *) + if test "$opt_mode" = clean ; then + noexename=$name + case $file in + *.exe) + func_stripname '' '.exe' "$file" + file=$func_stripname_result + func_stripname '' '.exe' "$name" + noexename=$func_stripname_result + # $file with .exe has already been added to rmfiles, + # add $file without .exe + func_append rmfiles " $file" + ;; + esac + # Do a test to see if this is a libtool program. + if func_ltwrapper_p "$file"; then + if func_ltwrapper_executable_p "$file"; then + func_ltwrapper_scriptname "$file" + relink_command= + func_source $func_ltwrapper_scriptname_result + func_append rmfiles " $func_ltwrapper_scriptname_result" + else + relink_command= + func_source $dir/$noexename + fi + + # note $name still contains .exe if it was in $file originally + # as does the version of $file that was added into $rmfiles + func_append rmfiles " $odir/$name $odir/${name}S.${objext}" + if test "$fast_install" = yes && test -n "$relink_command"; then + func_append rmfiles " $odir/lt-$name" + fi + if test "X$noexename" != "X$name" ; then + func_append rmfiles " $odir/lt-${noexename}.c" + fi + fi + fi + ;; + esac + func_show_eval "$RM $rmfiles" 'exit_status=1' + done + + # Try to remove the ${objdir}s in the directories where we deleted files + for dir in $rmdirs; do + if test -d "$dir"; then + func_show_eval "rmdir $dir >/dev/null 2>&1" + fi + done + + exit $exit_status +} + +{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } && + func_mode_uninstall ${1+"$@"} + +test -z "$opt_mode" && { + help="$generic_help" + func_fatal_help "you must specify a MODE" +} + +test -z "$exec_cmd" && \ + func_fatal_help "invalid operation mode \`$opt_mode'" + +if test -n "$exec_cmd"; then + eval exec "$exec_cmd" + exit $EXIT_FAILURE +fi + +exit $exit_status + + +# The TAGs below are defined such that we never get into a situation +# in which we disable both kinds of libraries. Given conflicting +# choices, we go for a static library, that is the most portable, +# since we can't tell whether shared libraries were disabled because +# the user asked for that or because the platform doesn't support +# them. This is particularly important on AIX, because we don't +# support having both static and shared libraries enabled at the same +# time on that platform, so we default to a shared-only configuration. +# If a disable-shared tag is given, we'll fallback to a static-only +# configuration. But we'll never go from static-only to shared-only. + +# ### BEGIN LIBTOOL TAG CONFIG: disable-shared +build_libtool_libs=no +build_old_libs=yes +# ### END LIBTOOL TAG CONFIG: disable-shared + +# ### BEGIN LIBTOOL TAG CONFIG: disable-static +build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac` +# ### END LIBTOOL TAG CONFIG: disable-static + +# Local Variables: +# mode:shell-script +# sh-indentation:2 +# End: +# vi:sw=2 + diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/m4/ac_python_devel.m4 b/native_client/ctcdecode/third_party/openfst-1.6.7/m4/ac_python_devel.m4 new file mode 100644 index 0000000000..48551562a7 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/m4/ac_python_devel.m4 @@ -0,0 +1,230 @@ +dnl @synopsis AC_PYTHON_DEVEL([version]) +dnl +dnl Note: Defines as a precious variable "PYTHON_VERSION". Don't +dnl override it in your configure.ac. +dnl +dnl This macro checks for Python and tries to get the include path to +dnl 'Python.h'. It provides the $(PYTHON_CPPFLAGS) and +dnl $(PYTHON_LDFLAGS) output variables. It also exports +dnl $(PYTHON_EXTRA_LIBS) and $(PYTHON_EXTRA_LDFLAGS) for embedding +dnl Python in your code. +dnl +dnl You can search for some particular version of Python by passing a +dnl parameter to this macro, for example ">= '2.3.1'", or "== '2.4'". +dnl Please note that you *have* to pass also an operator along with the +dnl version to match, and pay special attention to the single quotes +dnl surrounding the version number. Don't use "PYTHON_VERSION" for +dnl this: that environment variable is declared as precious and thus +dnl reserved for the end-user. +dnl +dnl This macro should work for all versions of Python >= 2.1.0. As an +dnl end user, you can disable the check for the python version by +dnl setting the PYTHON_NOVERSIONCHECK environment variable to something +dnl else than the empty string. +dnl +dnl If you need to use this macro for an older Python version, please +dnl contact the authors. We're always open for feedback. +dnl +dnl @category InstalledPackages +dnl @author Sebastian Huber +dnl @author Alan W. Irwin +dnl @author Rafael Laboissiere +dnl @author Andrew Collier +dnl @author Matteo Settenvini +dnl @author Horst Knorr +dnl @version 2006-05-27 +dnl @license GPLWithACException + +AC_DEFUN([AC_PYTHON_DEVEL],[ + # + # Allow the use of a (user set) custom python version + # + AC_ARG_VAR([PYTHON_VERSION],[The installed Python + version to use, for example '2.3'. This string + will be appended to the Python interpreter + canonical name.]) + + AC_PATH_PROG([PYTHON],[python[$PYTHON_VERSION]]) + if test -z "$PYTHON"; then + AC_MSG_ERROR([Cannot find python$PYTHON_VERSION in your system path]) + PYTHON_VERSION="" + fi + + # + # Check for a version of Python >= 2.1.0 + # + AC_MSG_CHECKING([for a version of Python >= '2.1.0']) + ac_supports_python_ver=`$PYTHON -c "import sys, string; \ + ver = string.split(sys.version)[[0]]; \ + print ver >= '2.1.0'"` + if test "$ac_supports_python_ver" != "True"; then + if test -z "$PYTHON_NOVERSIONCHECK"; then + AC_MSG_RESULT([no]) + AC_MSG_FAILURE([ +This version of the AC@&t@_PYTHON_DEVEL macro +doesn't work properly with versions of Python before +2.1.0. You may need to re-run configure, setting the +variables PYTHON_CPPFLAGS, PYTHON_LDFLAGS, PYTHON_SITE_PKG, +PYTHON_EXTRA_LIBS and PYTHON_EXTRA_LDFLAGS by hand. +Moreover, to disable this check, set PYTHON_NOVERSIONCHECK +to something else than an empty string. +]) + else + AC_MSG_RESULT([skip at user request]) + fi + else + AC_MSG_RESULT([yes]) + fi + + # + # if the macro parameter ``version'' is set, honour it + # + if test -n "$1"; then + AC_MSG_CHECKING([for a version of Python $1]) + ac_supports_python_ver=`$PYTHON -c "import sys, string; \ + ver = string.split(sys.version)[[0]]; \ + print ver $1"` + if test "$ac_supports_python_ver" = "True"; then + AC_MSG_RESULT([yes]) + else + AC_MSG_RESULT([no]) + AC_MSG_ERROR([this package requires Python $1. +If you have it installed, but it isn't the default Python +interpreter in your system path, please pass the PYTHON_VERSION +variable to configure. See ``configure --help'' for reference. +]) + PYTHON_VERSION="" + fi + fi + + # + # Check if you have distutils, else fail + # + AC_MSG_CHECKING([for the distutils Python package]) + ac_distutils_result=`$PYTHON -c "import distutils" 2>&1` + if test -z "$ac_distutils_result"; then + AC_MSG_RESULT([yes]) + else + AC_MSG_RESULT([no]) + AC_MSG_ERROR([cannot import Python module "distutils". +Please check your Python installation. The error was: +$ac_distutils_result]) + PYTHON_VERSION="" + fi + + # + # Check for Python include path + # + AC_MSG_CHECKING([for Python include path]) + if test -z "$PYTHON_CPPFLAGS"; then + python_path=`$PYTHON -c "import distutils.sysconfig; \ + print distutils.sysconfig.get_python_inc();"` + if test -n "${python_path}"; then + python_path="-I$python_path" + fi + PYTHON_CPPFLAGS=$python_path + fi + AC_MSG_RESULT([$PYTHON_CPPFLAGS]) + AC_SUBST([PYTHON_CPPFLAGS]) + + # + # Check for Python library path + # + AC_MSG_CHECKING([for Python library path]) + if test -z "$PYTHON_LDFLAGS"; then + # (makes two attempts to ensure we've got a version number + # from the interpreter) + py_version=`$PYTHON -c "from distutils.sysconfig import *; \ + from string import join; \ + print join(get_config_vars('VERSION'))"` + if test "$py_version" == "[None]"; then + if test -n "$PYTHON_VERSION"; then + py_version=$PYTHON_VERSION + else + py_version=`$PYTHON -c "import sys; \ + print sys.version[[:3]]"` + fi + fi + + PYTHON_LDFLAGS=`$PYTHON -c "from distutils.sysconfig import *; \ + from string import join; \ + print '-L' + get_python_lib(0,1), \ + '-lpython';"`$py_version + fi + AC_MSG_RESULT([$PYTHON_LDFLAGS]) + AC_SUBST([PYTHON_LDFLAGS]) + + # + # Check for site packages + # + AC_MSG_CHECKING([for Python site-packages path]) + if test -z "$PYTHON_SITE_PKG"; then + PYTHON_SITE_PKG=`$PYTHON -c "import distutils.sysconfig; \ + print distutils.sysconfig.get_python_lib(0,0);"` + fi + AC_MSG_RESULT([$PYTHON_SITE_PKG]) + AC_SUBST([PYTHON_SITE_PKG]) + + # + # libraries which must be linked in when embedding + # + AC_MSG_CHECKING(python extra libraries) + if test -z "$PYTHON_EXTRA_LIBS"; then + PYTHON_EXTRA_LIBS=`$PYTHON -c "import distutils.sysconfig; \ + conf = distutils.sysconfig.get_config_var; \ + print conf('LOCALMODLIBS'), conf('LIBS')"` + fi + AC_MSG_RESULT([$PYTHON_EXTRA_LIBS]) + AC_SUBST(PYTHON_EXTRA_LIBS) + + # + # linking flags needed when embedding + # + AC_MSG_CHECKING(python extra linking flags) + if test -z "$PYTHON_EXTRA_LDFLAGS"; then + PYTHON_EXTRA_LDFLAGS=`$PYTHON -c "import distutils.sysconfig; \ + conf = distutils.sysconfig.get_config_var; \ + print conf('LINKFORSHARED')"` + fi + AC_MSG_RESULT([$PYTHON_EXTRA_LDFLAGS]) + AC_SUBST(PYTHON_EXTRA_LDFLAGS) + + # + # final check to see if everything compiles alright + # + AC_MSG_CHECKING([consistency of all components of python development environment]) + AC_LANG_PUSH([C]) + # save current global flags + LIBS="$ac_save_LIBS $PYTHON_LDFLAGS" + CPPFLAGS="$ac_save_CPPFLAGS $PYTHON_CPPFLAGS" + AC_TRY_LINK([ + #include + ],[ + Py_Initialize(); + ],[pythonexists=yes],[pythonexists=no]) + + AC_MSG_RESULT([$pythonexists]) + + if test ! "$pythonexists" = "yes"; then + AC_MSG_ERROR([ + Could not link test program to Python. Maybe the main Python library has been + installed in some non-standard library path. If so, pass it to configure, + via the LDFLAGS environment variable. + Example: ./configure LDFLAGS="-L/usr/non-standard-path/python/lib" + ============================================================================ + ERROR! + You probably have to install the development version of the Python package + for your distribution. The exact name of this package varies among them. + ============================================================================ + ]) + PYTHON_VERSION="" + fi + AC_LANG_POP + # turn back to default flags + CPPFLAGS="$ac_save_CPPFLAGS" + LIBS="$ac_save_LIBS" + + # + # all done! + # +]) diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/m4/libtool.m4 b/native_client/ctcdecode/third_party/openfst-1.6.7/m4/libtool.m4 new file mode 100644 index 0000000000..d7c043f4f9 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/m4/libtool.m4 @@ -0,0 +1,7997 @@ +# libtool.m4 - Configure libtool for the host system. -*-Autoconf-*- +# +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, +# 2006, 2007, 2008, 2009, 2010, 2011 Free Software +# Foundation, Inc. +# Written by Gordon Matzigkeit, 1996 +# +# This file is free software; the Free Software Foundation gives +# unlimited permission to copy and/or distribute it, with or without +# modifications, as long as this notice is preserved. + +m4_define([_LT_COPYING], [dnl +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, +# 2006, 2007, 2008, 2009, 2010, 2011 Free Software +# Foundation, Inc. +# Written by Gordon Matzigkeit, 1996 +# +# This file is part of GNU Libtool. +# +# GNU Libtool is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License as +# published by the Free Software Foundation; either version 2 of +# the License, or (at your option) any later version. +# +# As a special exception to the GNU General Public License, +# if you distribute this file as part of a program or library that +# is built using GNU Libtool, you may include this file under the +# same distribution terms that you use for the rest of that program. +# +# GNU Libtool is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Libtool; see the file COPYING. If not, a copy +# can be downloaded from http://www.gnu.org/licenses/gpl.html, or +# obtained by writing to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +]) + +# serial 57 LT_INIT + + +# LT_PREREQ(VERSION) +# ------------------ +# Complain and exit if this libtool version is less that VERSION. +m4_defun([LT_PREREQ], +[m4_if(m4_version_compare(m4_defn([LT_PACKAGE_VERSION]), [$1]), -1, + [m4_default([$3], + [m4_fatal([Libtool version $1 or higher is required], + 63)])], + [$2])]) + + +# _LT_CHECK_BUILDDIR +# ------------------ +# Complain if the absolute build directory name contains unusual characters +m4_defun([_LT_CHECK_BUILDDIR], +[case `pwd` in + *\ * | *\ *) + AC_MSG_WARN([Libtool does not cope well with whitespace in `pwd`]) ;; +esac +]) + + +# LT_INIT([OPTIONS]) +# ------------------ +AC_DEFUN([LT_INIT], +[AC_PREREQ([2.58])dnl We use AC_INCLUDES_DEFAULT +AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl +AC_BEFORE([$0], [LT_LANG])dnl +AC_BEFORE([$0], [LT_OUTPUT])dnl +AC_BEFORE([$0], [LTDL_INIT])dnl +m4_require([_LT_CHECK_BUILDDIR])dnl + +dnl Autoconf doesn't catch unexpanded LT_ macros by default: +m4_pattern_forbid([^_?LT_[A-Z_]+$])dnl +m4_pattern_allow([^(_LT_EOF|LT_DLGLOBAL|LT_DLLAZY_OR_NOW|LT_MULTI_MODULE)$])dnl +dnl aclocal doesn't pull ltoptions.m4, ltsugar.m4, or ltversion.m4 +dnl unless we require an AC_DEFUNed macro: +AC_REQUIRE([LTOPTIONS_VERSION])dnl +AC_REQUIRE([LTSUGAR_VERSION])dnl +AC_REQUIRE([LTVERSION_VERSION])dnl +AC_REQUIRE([LTOBSOLETE_VERSION])dnl +m4_require([_LT_PROG_LTMAIN])dnl + +_LT_SHELL_INIT([SHELL=${CONFIG_SHELL-/bin/sh}]) + +dnl Parse OPTIONS +_LT_SET_OPTIONS([$0], [$1]) + +# This can be used to rebuild libtool when needed +LIBTOOL_DEPS="$ltmain" + +# Always use our own libtool. +LIBTOOL='$(SHELL) $(top_builddir)/libtool' +AC_SUBST(LIBTOOL)dnl + +_LT_SETUP + +# Only expand once: +m4_define([LT_INIT]) +])# LT_INIT + +# Old names: +AU_ALIAS([AC_PROG_LIBTOOL], [LT_INIT]) +AU_ALIAS([AM_PROG_LIBTOOL], [LT_INIT]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_PROG_LIBTOOL], []) +dnl AC_DEFUN([AM_PROG_LIBTOOL], []) + + +# _LT_CC_BASENAME(CC) +# ------------------- +# Calculate cc_basename. Skip known compiler wrappers and cross-prefix. +m4_defun([_LT_CC_BASENAME], +[for cc_temp in $1""; do + case $cc_temp in + compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;; + distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;; + \-*) ;; + *) break;; + esac +done +cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` +]) + + +# _LT_FILEUTILS_DEFAULTS +# ---------------------- +# It is okay to use these file commands and assume they have been set +# sensibly after `m4_require([_LT_FILEUTILS_DEFAULTS])'. +m4_defun([_LT_FILEUTILS_DEFAULTS], +[: ${CP="cp -f"} +: ${MV="mv -f"} +: ${RM="rm -f"} +])# _LT_FILEUTILS_DEFAULTS + + +# _LT_SETUP +# --------- +m4_defun([_LT_SETUP], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +AC_REQUIRE([AC_CANONICAL_BUILD])dnl +AC_REQUIRE([_LT_PREPARE_SED_QUOTE_VARS])dnl +AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])dnl + +_LT_DECL([], [PATH_SEPARATOR], [1], [The PATH separator for the build system])dnl +dnl +_LT_DECL([], [host_alias], [0], [The host system])dnl +_LT_DECL([], [host], [0])dnl +_LT_DECL([], [host_os], [0])dnl +dnl +_LT_DECL([], [build_alias], [0], [The build system])dnl +_LT_DECL([], [build], [0])dnl +_LT_DECL([], [build_os], [0])dnl +dnl +AC_REQUIRE([AC_PROG_CC])dnl +AC_REQUIRE([LT_PATH_LD])dnl +AC_REQUIRE([LT_PATH_NM])dnl +dnl +AC_REQUIRE([AC_PROG_LN_S])dnl +test -z "$LN_S" && LN_S="ln -s" +_LT_DECL([], [LN_S], [1], [Whether we need soft or hard links])dnl +dnl +AC_REQUIRE([LT_CMD_MAX_LEN])dnl +_LT_DECL([objext], [ac_objext], [0], [Object file suffix (normally "o")])dnl +_LT_DECL([], [exeext], [0], [Executable file suffix (normally "")])dnl +dnl +m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_CHECK_SHELL_FEATURES])dnl +m4_require([_LT_PATH_CONVERSION_FUNCTIONS])dnl +m4_require([_LT_CMD_RELOAD])dnl +m4_require([_LT_CHECK_MAGIC_METHOD])dnl +m4_require([_LT_CHECK_SHAREDLIB_FROM_LINKLIB])dnl +m4_require([_LT_CMD_OLD_ARCHIVE])dnl +m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl +m4_require([_LT_WITH_SYSROOT])dnl + +_LT_CONFIG_LIBTOOL_INIT([ +# See if we are running on zsh, and set the options which allow our +# commands through without removal of \ escapes INIT. +if test -n "\${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST +fi +]) +if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST +fi + +_LT_CHECK_OBJDIR + +m4_require([_LT_TAG_COMPILER])dnl + +case $host_os in +aix3*) + # AIX sometimes has problems with the GCC collect2 program. For some + # reason, if we set the COLLECT_NAMES environment variable, the problems + # vanish in a puff of smoke. + if test "X${COLLECT_NAMES+set}" != Xset; then + COLLECT_NAMES= + export COLLECT_NAMES + fi + ;; +esac + +# Global variables: +ofile=libtool +can_build_shared=yes + +# All known linkers require a `.a' archive for static linking (except MSVC, +# which needs '.lib'). +libext=a + +with_gnu_ld="$lt_cv_prog_gnu_ld" + +old_CC="$CC" +old_CFLAGS="$CFLAGS" + +# Set sane defaults for various variables +test -z "$CC" && CC=cc +test -z "$LTCC" && LTCC=$CC +test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS +test -z "$LD" && LD=ld +test -z "$ac_objext" && ac_objext=o + +_LT_CC_BASENAME([$compiler]) + +# Only perform the check for file, if the check method requires it +test -z "$MAGIC_CMD" && MAGIC_CMD=file +case $deplibs_check_method in +file_magic*) + if test "$file_magic_cmd" = '$MAGIC_CMD'; then + _LT_PATH_MAGIC + fi + ;; +esac + +# Use C for the default configuration in the libtool script +LT_SUPPORTED_TAG([CC]) +_LT_LANG_C_CONFIG +_LT_LANG_DEFAULT_CONFIG +_LT_CONFIG_COMMANDS +])# _LT_SETUP + + +# _LT_PREPARE_SED_QUOTE_VARS +# -------------------------- +# Define a few sed substitution that help us do robust quoting. +m4_defun([_LT_PREPARE_SED_QUOTE_VARS], +[# Backslashify metacharacters that are still active within +# double-quoted strings. +sed_quote_subst='s/\([["`$\\]]\)/\\\1/g' + +# Same as above, but do not quote variable references. +double_quote_subst='s/\([["`\\]]\)/\\\1/g' + +# Sed substitution to delay expansion of an escaped shell variable in a +# double_quote_subst'ed string. +delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g' + +# Sed substitution to delay expansion of an escaped single quote. +delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g' + +# Sed substitution to avoid accidental globbing in evaled expressions +no_glob_subst='s/\*/\\\*/g' +]) + +# _LT_PROG_LTMAIN +# --------------- +# Note that this code is called both from `configure', and `config.status' +# now that we use AC_CONFIG_COMMANDS to generate libtool. Notably, +# `config.status' has no value for ac_aux_dir unless we are using Automake, +# so we pass a copy along to make sure it has a sensible value anyway. +m4_defun([_LT_PROG_LTMAIN], +[m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([ltmain.sh])])dnl +_LT_CONFIG_LIBTOOL_INIT([ac_aux_dir='$ac_aux_dir']) +ltmain="$ac_aux_dir/ltmain.sh" +])# _LT_PROG_LTMAIN + + +## ------------------------------------- ## +## Accumulate code for creating libtool. ## +## ------------------------------------- ## + +# So that we can recreate a full libtool script including additional +# tags, we accumulate the chunks of code to send to AC_CONFIG_COMMANDS +# in macros and then make a single call at the end using the `libtool' +# label. + + +# _LT_CONFIG_LIBTOOL_INIT([INIT-COMMANDS]) +# ---------------------------------------- +# Register INIT-COMMANDS to be passed to AC_CONFIG_COMMANDS later. +m4_define([_LT_CONFIG_LIBTOOL_INIT], +[m4_ifval([$1], + [m4_append([_LT_OUTPUT_LIBTOOL_INIT], + [$1 +])])]) + +# Initialize. +m4_define([_LT_OUTPUT_LIBTOOL_INIT]) + + +# _LT_CONFIG_LIBTOOL([COMMANDS]) +# ------------------------------ +# Register COMMANDS to be passed to AC_CONFIG_COMMANDS later. +m4_define([_LT_CONFIG_LIBTOOL], +[m4_ifval([$1], + [m4_append([_LT_OUTPUT_LIBTOOL_COMMANDS], + [$1 +])])]) + +# Initialize. +m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS]) + + +# _LT_CONFIG_SAVE_COMMANDS([COMMANDS], [INIT_COMMANDS]) +# ----------------------------------------------------- +m4_defun([_LT_CONFIG_SAVE_COMMANDS], +[_LT_CONFIG_LIBTOOL([$1]) +_LT_CONFIG_LIBTOOL_INIT([$2]) +]) + + +# _LT_FORMAT_COMMENT([COMMENT]) +# ----------------------------- +# Add leading comment marks to the start of each line, and a trailing +# full-stop to the whole comment if one is not present already. +m4_define([_LT_FORMAT_COMMENT], +[m4_ifval([$1], [ +m4_bpatsubst([m4_bpatsubst([$1], [^ *], [# ])], + [['`$\]], [\\\&])]m4_bmatch([$1], [[!?.]$], [], [.]) +)]) + + + +## ------------------------ ## +## FIXME: Eliminate VARNAME ## +## ------------------------ ## + + +# _LT_DECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION], [IS-TAGGED?]) +# ------------------------------------------------------------------- +# CONFIGNAME is the name given to the value in the libtool script. +# VARNAME is the (base) name used in the configure script. +# VALUE may be 0, 1 or 2 for a computed quote escaped value based on +# VARNAME. Any other value will be used directly. +m4_define([_LT_DECL], +[lt_if_append_uniq([lt_decl_varnames], [$2], [, ], + [lt_dict_add_subkey([lt_decl_dict], [$2], [libtool_name], + [m4_ifval([$1], [$1], [$2])]) + lt_dict_add_subkey([lt_decl_dict], [$2], [value], [$3]) + m4_ifval([$4], + [lt_dict_add_subkey([lt_decl_dict], [$2], [description], [$4])]) + lt_dict_add_subkey([lt_decl_dict], [$2], + [tagged?], [m4_ifval([$5], [yes], [no])])]) +]) + + +# _LT_TAGDECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION]) +# -------------------------------------------------------- +m4_define([_LT_TAGDECL], [_LT_DECL([$1], [$2], [$3], [$4], [yes])]) + + +# lt_decl_tag_varnames([SEPARATOR], [VARNAME1...]) +# ------------------------------------------------ +m4_define([lt_decl_tag_varnames], +[_lt_decl_filter([tagged?], [yes], $@)]) + + +# _lt_decl_filter(SUBKEY, VALUE, [SEPARATOR], [VARNAME1..]) +# --------------------------------------------------------- +m4_define([_lt_decl_filter], +[m4_case([$#], + [0], [m4_fatal([$0: too few arguments: $#])], + [1], [m4_fatal([$0: too few arguments: $#: $1])], + [2], [lt_dict_filter([lt_decl_dict], [$1], [$2], [], lt_decl_varnames)], + [3], [lt_dict_filter([lt_decl_dict], [$1], [$2], [$3], lt_decl_varnames)], + [lt_dict_filter([lt_decl_dict], $@)])[]dnl +]) + + +# lt_decl_quote_varnames([SEPARATOR], [VARNAME1...]) +# -------------------------------------------------- +m4_define([lt_decl_quote_varnames], +[_lt_decl_filter([value], [1], $@)]) + + +# lt_decl_dquote_varnames([SEPARATOR], [VARNAME1...]) +# --------------------------------------------------- +m4_define([lt_decl_dquote_varnames], +[_lt_decl_filter([value], [2], $@)]) + + +# lt_decl_varnames_tagged([SEPARATOR], [VARNAME1...]) +# --------------------------------------------------- +m4_define([lt_decl_varnames_tagged], +[m4_assert([$# <= 2])dnl +_$0(m4_quote(m4_default([$1], [[, ]])), + m4_ifval([$2], [[$2]], [m4_dquote(lt_decl_tag_varnames)]), + m4_split(m4_normalize(m4_quote(_LT_TAGS)), [ ]))]) +m4_define([_lt_decl_varnames_tagged], +[m4_ifval([$3], [lt_combine([$1], [$2], [_], $3)])]) + + +# lt_decl_all_varnames([SEPARATOR], [VARNAME1...]) +# ------------------------------------------------ +m4_define([lt_decl_all_varnames], +[_$0(m4_quote(m4_default([$1], [[, ]])), + m4_if([$2], [], + m4_quote(lt_decl_varnames), + m4_quote(m4_shift($@))))[]dnl +]) +m4_define([_lt_decl_all_varnames], +[lt_join($@, lt_decl_varnames_tagged([$1], + lt_decl_tag_varnames([[, ]], m4_shift($@))))dnl +]) + + +# _LT_CONFIG_STATUS_DECLARE([VARNAME]) +# ------------------------------------ +# Quote a variable value, and forward it to `config.status' so that its +# declaration there will have the same value as in `configure'. VARNAME +# must have a single quote delimited value for this to work. +m4_define([_LT_CONFIG_STATUS_DECLARE], +[$1='`$ECHO "$][$1" | $SED "$delay_single_quote_subst"`']) + + +# _LT_CONFIG_STATUS_DECLARATIONS +# ------------------------------ +# We delimit libtool config variables with single quotes, so when +# we write them to config.status, we have to be sure to quote all +# embedded single quotes properly. In configure, this macro expands +# each variable declared with _LT_DECL (and _LT_TAGDECL) into: +# +# ='`$ECHO "$" | $SED "$delay_single_quote_subst"`' +m4_defun([_LT_CONFIG_STATUS_DECLARATIONS], +[m4_foreach([_lt_var], m4_quote(lt_decl_all_varnames), + [m4_n([_LT_CONFIG_STATUS_DECLARE(_lt_var)])])]) + + +# _LT_LIBTOOL_TAGS +# ---------------- +# Output comment and list of tags supported by the script +m4_defun([_LT_LIBTOOL_TAGS], +[_LT_FORMAT_COMMENT([The names of the tagged configurations supported by this script])dnl +available_tags="_LT_TAGS"dnl +]) + + +# _LT_LIBTOOL_DECLARE(VARNAME, [TAG]) +# ----------------------------------- +# Extract the dictionary values for VARNAME (optionally with TAG) and +# expand to a commented shell variable setting: +# +# # Some comment about what VAR is for. +# visible_name=$lt_internal_name +m4_define([_LT_LIBTOOL_DECLARE], +[_LT_FORMAT_COMMENT(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], + [description])))[]dnl +m4_pushdef([_libtool_name], + m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [libtool_name])))[]dnl +m4_case(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [value])), + [0], [_libtool_name=[$]$1], + [1], [_libtool_name=$lt_[]$1], + [2], [_libtool_name=$lt_[]$1], + [_libtool_name=lt_dict_fetch([lt_decl_dict], [$1], [value])])[]dnl +m4_ifval([$2], [_$2])[]m4_popdef([_libtool_name])[]dnl +]) + + +# _LT_LIBTOOL_CONFIG_VARS +# ----------------------- +# Produce commented declarations of non-tagged libtool config variables +# suitable for insertion in the LIBTOOL CONFIG section of the `libtool' +# script. Tagged libtool config variables (even for the LIBTOOL CONFIG +# section) are produced by _LT_LIBTOOL_TAG_VARS. +m4_defun([_LT_LIBTOOL_CONFIG_VARS], +[m4_foreach([_lt_var], + m4_quote(_lt_decl_filter([tagged?], [no], [], lt_decl_varnames)), + [m4_n([_LT_LIBTOOL_DECLARE(_lt_var)])])]) + + +# _LT_LIBTOOL_TAG_VARS(TAG) +# ------------------------- +m4_define([_LT_LIBTOOL_TAG_VARS], +[m4_foreach([_lt_var], m4_quote(lt_decl_tag_varnames), + [m4_n([_LT_LIBTOOL_DECLARE(_lt_var, [$1])])])]) + + +# _LT_TAGVAR(VARNAME, [TAGNAME]) +# ------------------------------ +m4_define([_LT_TAGVAR], [m4_ifval([$2], [$1_$2], [$1])]) + + +# _LT_CONFIG_COMMANDS +# ------------------- +# Send accumulated output to $CONFIG_STATUS. Thanks to the lists of +# variables for single and double quote escaping we saved from calls +# to _LT_DECL, we can put quote escaped variables declarations +# into `config.status', and then the shell code to quote escape them in +# for loops in `config.status'. Finally, any additional code accumulated +# from calls to _LT_CONFIG_LIBTOOL_INIT is expanded. +m4_defun([_LT_CONFIG_COMMANDS], +[AC_PROVIDE_IFELSE([LT_OUTPUT], + dnl If the libtool generation code has been placed in $CONFIG_LT, + dnl instead of duplicating it all over again into config.status, + dnl then we will have config.status run $CONFIG_LT later, so it + dnl needs to know what name is stored there: + [AC_CONFIG_COMMANDS([libtool], + [$SHELL $CONFIG_LT || AS_EXIT(1)], [CONFIG_LT='$CONFIG_LT'])], + dnl If the libtool generation code is destined for config.status, + dnl expand the accumulated commands and init code now: + [AC_CONFIG_COMMANDS([libtool], + [_LT_OUTPUT_LIBTOOL_COMMANDS], [_LT_OUTPUT_LIBTOOL_COMMANDS_INIT])]) +])#_LT_CONFIG_COMMANDS + + +# Initialize. +m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS_INIT], +[ + +# The HP-UX ksh and POSIX shell print the target directory to stdout +# if CDPATH is set. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + +sed_quote_subst='$sed_quote_subst' +double_quote_subst='$double_quote_subst' +delay_variable_subst='$delay_variable_subst' +_LT_CONFIG_STATUS_DECLARATIONS +LTCC='$LTCC' +LTCFLAGS='$LTCFLAGS' +compiler='$compiler_DEFAULT' + +# A function that is used when there is no print builtin or printf. +func_fallback_echo () +{ + eval 'cat <<_LTECHO_EOF +\$[]1 +_LTECHO_EOF' +} + +# Quote evaled strings. +for var in lt_decl_all_varnames([[ \ +]], lt_decl_quote_varnames); do + case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in + *[[\\\\\\\`\\"\\\$]]*) + eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" + ;; + *) + eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" + ;; + esac +done + +# Double-quote double-evaled strings. +for var in lt_decl_all_varnames([[ \ +]], lt_decl_dquote_varnames); do + case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in + *[[\\\\\\\`\\"\\\$]]*) + eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" + ;; + *) + eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" + ;; + esac +done + +_LT_OUTPUT_LIBTOOL_INIT +]) + +# _LT_GENERATED_FILE_INIT(FILE, [COMMENT]) +# ------------------------------------ +# Generate a child script FILE with all initialization necessary to +# reuse the environment learned by the parent script, and make the +# file executable. If COMMENT is supplied, it is inserted after the +# `#!' sequence but before initialization text begins. After this +# macro, additional text can be appended to FILE to form the body of +# the child script. The macro ends with non-zero status if the +# file could not be fully written (such as if the disk is full). +m4_ifdef([AS_INIT_GENERATED], +[m4_defun([_LT_GENERATED_FILE_INIT],[AS_INIT_GENERATED($@)])], +[m4_defun([_LT_GENERATED_FILE_INIT], +[m4_require([AS_PREPARE])]dnl +[m4_pushdef([AS_MESSAGE_LOG_FD])]dnl +[lt_write_fail=0 +cat >$1 <<_ASEOF || lt_write_fail=1 +#! $SHELL +# Generated by $as_me. +$2 +SHELL=\${CONFIG_SHELL-$SHELL} +export SHELL +_ASEOF +cat >>$1 <<\_ASEOF || lt_write_fail=1 +AS_SHELL_SANITIZE +_AS_PREPARE +exec AS_MESSAGE_FD>&1 +_ASEOF +test $lt_write_fail = 0 && chmod +x $1[]dnl +m4_popdef([AS_MESSAGE_LOG_FD])])])# _LT_GENERATED_FILE_INIT + +# LT_OUTPUT +# --------- +# This macro allows early generation of the libtool script (before +# AC_OUTPUT is called), incase it is used in configure for compilation +# tests. +AC_DEFUN([LT_OUTPUT], +[: ${CONFIG_LT=./config.lt} +AC_MSG_NOTICE([creating $CONFIG_LT]) +_LT_GENERATED_FILE_INIT(["$CONFIG_LT"], +[# Run this file to recreate a libtool stub with the current configuration.]) + +cat >>"$CONFIG_LT" <<\_LTEOF +lt_cl_silent=false +exec AS_MESSAGE_LOG_FD>>config.log +{ + echo + AS_BOX([Running $as_me.]) +} >&AS_MESSAGE_LOG_FD + +lt_cl_help="\ +\`$as_me' creates a local libtool stub from the current configuration, +for use in further configure time tests before the real libtool is +generated. + +Usage: $[0] [[OPTIONS]] + + -h, --help print this help, then exit + -V, --version print version number, then exit + -q, --quiet do not print progress messages + -d, --debug don't remove temporary files + +Report bugs to ." + +lt_cl_version="\ +m4_ifset([AC_PACKAGE_NAME], [AC_PACKAGE_NAME ])config.lt[]dnl +m4_ifset([AC_PACKAGE_VERSION], [ AC_PACKAGE_VERSION]) +configured by $[0], generated by m4_PACKAGE_STRING. + +Copyright (C) 2011 Free Software Foundation, Inc. +This config.lt script is free software; the Free Software Foundation +gives unlimited permision to copy, distribute and modify it." + +while test $[#] != 0 +do + case $[1] in + --version | --v* | -V ) + echo "$lt_cl_version"; exit 0 ;; + --help | --h* | -h ) + echo "$lt_cl_help"; exit 0 ;; + --debug | --d* | -d ) + debug=: ;; + --quiet | --q* | --silent | --s* | -q ) + lt_cl_silent=: ;; + + -*) AC_MSG_ERROR([unrecognized option: $[1] +Try \`$[0] --help' for more information.]) ;; + + *) AC_MSG_ERROR([unrecognized argument: $[1] +Try \`$[0] --help' for more information.]) ;; + esac + shift +done + +if $lt_cl_silent; then + exec AS_MESSAGE_FD>/dev/null +fi +_LTEOF + +cat >>"$CONFIG_LT" <<_LTEOF +_LT_OUTPUT_LIBTOOL_COMMANDS_INIT +_LTEOF + +cat >>"$CONFIG_LT" <<\_LTEOF +AC_MSG_NOTICE([creating $ofile]) +_LT_OUTPUT_LIBTOOL_COMMANDS +AS_EXIT(0) +_LTEOF +chmod +x "$CONFIG_LT" + +# configure is writing to config.log, but config.lt does its own redirection, +# appending to config.log, which fails on DOS, as config.log is still kept +# open by configure. Here we exec the FD to /dev/null, effectively closing +# config.log, so it can be properly (re)opened and appended to by config.lt. +lt_cl_success=: +test "$silent" = yes && + lt_config_lt_args="$lt_config_lt_args --quiet" +exec AS_MESSAGE_LOG_FD>/dev/null +$SHELL "$CONFIG_LT" $lt_config_lt_args || lt_cl_success=false +exec AS_MESSAGE_LOG_FD>>config.log +$lt_cl_success || AS_EXIT(1) +])# LT_OUTPUT + + +# _LT_CONFIG(TAG) +# --------------- +# If TAG is the built-in tag, create an initial libtool script with a +# default configuration from the untagged config vars. Otherwise add code +# to config.status for appending the configuration named by TAG from the +# matching tagged config vars. +m4_defun([_LT_CONFIG], +[m4_require([_LT_FILEUTILS_DEFAULTS])dnl +_LT_CONFIG_SAVE_COMMANDS([ + m4_define([_LT_TAG], m4_if([$1], [], [C], [$1]))dnl + m4_if(_LT_TAG, [C], [ + # See if we are running on zsh, and set the options which allow our + # commands through without removal of \ escapes. + if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST + fi + + cfgfile="${ofile}T" + trap "$RM \"$cfgfile\"; exit 1" 1 2 15 + $RM "$cfgfile" + + cat <<_LT_EOF >> "$cfgfile" +#! $SHELL + +# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services. +# Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION +# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: +# NOTE: Changes made to this file will be lost: look at ltmain.sh. +# +_LT_COPYING +_LT_LIBTOOL_TAGS + +# ### BEGIN LIBTOOL CONFIG +_LT_LIBTOOL_CONFIG_VARS +_LT_LIBTOOL_TAG_VARS +# ### END LIBTOOL CONFIG + +_LT_EOF + + case $host_os in + aix3*) + cat <<\_LT_EOF >> "$cfgfile" +# AIX sometimes has problems with the GCC collect2 program. For some +# reason, if we set the COLLECT_NAMES environment variable, the problems +# vanish in a puff of smoke. +if test "X${COLLECT_NAMES+set}" != Xset; then + COLLECT_NAMES= + export COLLECT_NAMES +fi +_LT_EOF + ;; + esac + + _LT_PROG_LTMAIN + + # We use sed instead of cat because bash on DJGPP gets confused if + # if finds mixed CR/LF and LF-only lines. Since sed operates in + # text mode, it properly converts lines to CR/LF. This bash problem + # is reportedly fixed, but why not run on old versions too? + sed '$q' "$ltmain" >> "$cfgfile" \ + || (rm -f "$cfgfile"; exit 1) + + _LT_PROG_REPLACE_SHELLFNS + + mv -f "$cfgfile" "$ofile" || + (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile") + chmod +x "$ofile" +], +[cat <<_LT_EOF >> "$ofile" + +dnl Unfortunately we have to use $1 here, since _LT_TAG is not expanded +dnl in a comment (ie after a #). +# ### BEGIN LIBTOOL TAG CONFIG: $1 +_LT_LIBTOOL_TAG_VARS(_LT_TAG) +# ### END LIBTOOL TAG CONFIG: $1 +_LT_EOF +])dnl /m4_if +], +[m4_if([$1], [], [ + PACKAGE='$PACKAGE' + VERSION='$VERSION' + TIMESTAMP='$TIMESTAMP' + RM='$RM' + ofile='$ofile'], []) +])dnl /_LT_CONFIG_SAVE_COMMANDS +])# _LT_CONFIG + + +# LT_SUPPORTED_TAG(TAG) +# --------------------- +# Trace this macro to discover what tags are supported by the libtool +# --tag option, using: +# autoconf --trace 'LT_SUPPORTED_TAG:$1' +AC_DEFUN([LT_SUPPORTED_TAG], []) + + +# C support is built-in for now +m4_define([_LT_LANG_C_enabled], []) +m4_define([_LT_TAGS], []) + + +# LT_LANG(LANG) +# ------------- +# Enable libtool support for the given language if not already enabled. +AC_DEFUN([LT_LANG], +[AC_BEFORE([$0], [LT_OUTPUT])dnl +m4_case([$1], + [C], [_LT_LANG(C)], + [C++], [_LT_LANG(CXX)], + [Go], [_LT_LANG(GO)], + [Java], [_LT_LANG(GCJ)], + [Fortran 77], [_LT_LANG(F77)], + [Fortran], [_LT_LANG(FC)], + [Windows Resource], [_LT_LANG(RC)], + [m4_ifdef([_LT_LANG_]$1[_CONFIG], + [_LT_LANG($1)], + [m4_fatal([$0: unsupported language: "$1"])])])dnl +])# LT_LANG + + +# _LT_LANG(LANGNAME) +# ------------------ +m4_defun([_LT_LANG], +[m4_ifdef([_LT_LANG_]$1[_enabled], [], + [LT_SUPPORTED_TAG([$1])dnl + m4_append([_LT_TAGS], [$1 ])dnl + m4_define([_LT_LANG_]$1[_enabled], [])dnl + _LT_LANG_$1_CONFIG($1)])dnl +])# _LT_LANG + + +m4_ifndef([AC_PROG_GO], [ +############################################################ +# NOTE: This macro has been submitted for inclusion into # +# GNU Autoconf as AC_PROG_GO. When it is available in # +# a released version of Autoconf we should remove this # +# macro and use it instead. # +############################################################ +m4_defun([AC_PROG_GO], +[AC_LANG_PUSH(Go)dnl +AC_ARG_VAR([GOC], [Go compiler command])dnl +AC_ARG_VAR([GOFLAGS], [Go compiler flags])dnl +_AC_ARG_VAR_LDFLAGS()dnl +AC_CHECK_TOOL(GOC, gccgo) +if test -z "$GOC"; then + if test -n "$ac_tool_prefix"; then + AC_CHECK_PROG(GOC, [${ac_tool_prefix}gccgo], [${ac_tool_prefix}gccgo]) + fi +fi +if test -z "$GOC"; then + AC_CHECK_PROG(GOC, gccgo, gccgo, false) +fi +])#m4_defun +])#m4_ifndef + + +# _LT_LANG_DEFAULT_CONFIG +# ----------------------- +m4_defun([_LT_LANG_DEFAULT_CONFIG], +[AC_PROVIDE_IFELSE([AC_PROG_CXX], + [LT_LANG(CXX)], + [m4_define([AC_PROG_CXX], defn([AC_PROG_CXX])[LT_LANG(CXX)])]) + +AC_PROVIDE_IFELSE([AC_PROG_F77], + [LT_LANG(F77)], + [m4_define([AC_PROG_F77], defn([AC_PROG_F77])[LT_LANG(F77)])]) + +AC_PROVIDE_IFELSE([AC_PROG_FC], + [LT_LANG(FC)], + [m4_define([AC_PROG_FC], defn([AC_PROG_FC])[LT_LANG(FC)])]) + +dnl The call to [A][M_PROG_GCJ] is quoted like that to stop aclocal +dnl pulling things in needlessly. +AC_PROVIDE_IFELSE([AC_PROG_GCJ], + [LT_LANG(GCJ)], + [AC_PROVIDE_IFELSE([A][M_PROG_GCJ], + [LT_LANG(GCJ)], + [AC_PROVIDE_IFELSE([LT_PROG_GCJ], + [LT_LANG(GCJ)], + [m4_ifdef([AC_PROG_GCJ], + [m4_define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[LT_LANG(GCJ)])]) + m4_ifdef([A][M_PROG_GCJ], + [m4_define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[LT_LANG(GCJ)])]) + m4_ifdef([LT_PROG_GCJ], + [m4_define([LT_PROG_GCJ], defn([LT_PROG_GCJ])[LT_LANG(GCJ)])])])])]) + +AC_PROVIDE_IFELSE([AC_PROG_GO], + [LT_LANG(GO)], + [m4_define([AC_PROG_GO], defn([AC_PROG_GO])[LT_LANG(GO)])]) + +AC_PROVIDE_IFELSE([LT_PROG_RC], + [LT_LANG(RC)], + [m4_define([LT_PROG_RC], defn([LT_PROG_RC])[LT_LANG(RC)])]) +])# _LT_LANG_DEFAULT_CONFIG + +# Obsolete macros: +AU_DEFUN([AC_LIBTOOL_CXX], [LT_LANG(C++)]) +AU_DEFUN([AC_LIBTOOL_F77], [LT_LANG(Fortran 77)]) +AU_DEFUN([AC_LIBTOOL_FC], [LT_LANG(Fortran)]) +AU_DEFUN([AC_LIBTOOL_GCJ], [LT_LANG(Java)]) +AU_DEFUN([AC_LIBTOOL_RC], [LT_LANG(Windows Resource)]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_CXX], []) +dnl AC_DEFUN([AC_LIBTOOL_F77], []) +dnl AC_DEFUN([AC_LIBTOOL_FC], []) +dnl AC_DEFUN([AC_LIBTOOL_GCJ], []) +dnl AC_DEFUN([AC_LIBTOOL_RC], []) + + +# _LT_TAG_COMPILER +# ---------------- +m4_defun([_LT_TAG_COMPILER], +[AC_REQUIRE([AC_PROG_CC])dnl + +_LT_DECL([LTCC], [CC], [1], [A C compiler])dnl +_LT_DECL([LTCFLAGS], [CFLAGS], [1], [LTCC compiler flags])dnl +_LT_TAGDECL([CC], [compiler], [1], [A language specific compiler])dnl +_LT_TAGDECL([with_gcc], [GCC], [0], [Is the compiler the GNU compiler?])dnl + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# If no C compiler flags were specified, use CFLAGS. +LTCFLAGS=${LTCFLAGS-"$CFLAGS"} + +# Allow CC to be a program name with arguments. +compiler=$CC +])# _LT_TAG_COMPILER + + +# _LT_COMPILER_BOILERPLATE +# ------------------------ +# Check for compiler boilerplate output or warnings with +# the simple compiler test code. +m4_defun([_LT_COMPILER_BOILERPLATE], +[m4_require([_LT_DECL_SED])dnl +ac_outfile=conftest.$ac_objext +echo "$lt_simple_compile_test_code" >conftest.$ac_ext +eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err +_lt_compiler_boilerplate=`cat conftest.err` +$RM conftest* +])# _LT_COMPILER_BOILERPLATE + + +# _LT_LINKER_BOILERPLATE +# ---------------------- +# Check for linker boilerplate output or warnings with +# the simple link test code. +m4_defun([_LT_LINKER_BOILERPLATE], +[m4_require([_LT_DECL_SED])dnl +ac_outfile=conftest.$ac_objext +echo "$lt_simple_link_test_code" >conftest.$ac_ext +eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err +_lt_linker_boilerplate=`cat conftest.err` +$RM -r conftest* +])# _LT_LINKER_BOILERPLATE + +# _LT_REQUIRED_DARWIN_CHECKS +# ------------------------- +m4_defun_once([_LT_REQUIRED_DARWIN_CHECKS],[ + case $host_os in + rhapsody* | darwin*) + AC_CHECK_TOOL([DSYMUTIL], [dsymutil], [:]) + AC_CHECK_TOOL([NMEDIT], [nmedit], [:]) + AC_CHECK_TOOL([LIPO], [lipo], [:]) + AC_CHECK_TOOL([OTOOL], [otool], [:]) + AC_CHECK_TOOL([OTOOL64], [otool64], [:]) + _LT_DECL([], [DSYMUTIL], [1], + [Tool to manipulate archived DWARF debug symbol files on Mac OS X]) + _LT_DECL([], [NMEDIT], [1], + [Tool to change global to local symbols on Mac OS X]) + _LT_DECL([], [LIPO], [1], + [Tool to manipulate fat objects and archives on Mac OS X]) + _LT_DECL([], [OTOOL], [1], + [ldd/readelf like tool for Mach-O binaries on Mac OS X]) + _LT_DECL([], [OTOOL64], [1], + [ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4]) + + AC_CACHE_CHECK([for -single_module linker flag],[lt_cv_apple_cc_single_mod], + [lt_cv_apple_cc_single_mod=no + if test -z "${LT_MULTI_MODULE}"; then + # By default we will add the -single_module flag. You can override + # by either setting the environment variable LT_MULTI_MODULE + # non-empty at configure time, or by adding -multi_module to the + # link flags. + rm -rf libconftest.dylib* + echo "int foo(void){return 1;}" > conftest.c + echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \ +-dynamiclib -Wl,-single_module conftest.c" >&AS_MESSAGE_LOG_FD + $LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \ + -dynamiclib -Wl,-single_module conftest.c 2>conftest.err + _lt_result=$? + # If there is a non-empty error log, and "single_module" + # appears in it, assume the flag caused a linker warning + if test -s conftest.err && $GREP single_module conftest.err; then + cat conftest.err >&AS_MESSAGE_LOG_FD + # Otherwise, if the output was created with a 0 exit code from + # the compiler, it worked. + elif test -f libconftest.dylib && test $_lt_result -eq 0; then + lt_cv_apple_cc_single_mod=yes + else + cat conftest.err >&AS_MESSAGE_LOG_FD + fi + rm -rf libconftest.dylib* + rm -f conftest.* + fi]) + + AC_CACHE_CHECK([for -exported_symbols_list linker flag], + [lt_cv_ld_exported_symbols_list], + [lt_cv_ld_exported_symbols_list=no + save_LDFLAGS=$LDFLAGS + echo "_main" > conftest.sym + LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym" + AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], + [lt_cv_ld_exported_symbols_list=yes], + [lt_cv_ld_exported_symbols_list=no]) + LDFLAGS="$save_LDFLAGS" + ]) + + AC_CACHE_CHECK([for -force_load linker flag],[lt_cv_ld_force_load], + [lt_cv_ld_force_load=no + cat > conftest.c << _LT_EOF +int forced_loaded() { return 2;} +_LT_EOF + echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&AS_MESSAGE_LOG_FD + $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&AS_MESSAGE_LOG_FD + echo "$AR cru libconftest.a conftest.o" >&AS_MESSAGE_LOG_FD + $AR cru libconftest.a conftest.o 2>&AS_MESSAGE_LOG_FD + echo "$RANLIB libconftest.a" >&AS_MESSAGE_LOG_FD + $RANLIB libconftest.a 2>&AS_MESSAGE_LOG_FD + cat > conftest.c << _LT_EOF +int main() { return 0;} +_LT_EOF + echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&AS_MESSAGE_LOG_FD + $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err + _lt_result=$? + if test -s conftest.err && $GREP force_load conftest.err; then + cat conftest.err >&AS_MESSAGE_LOG_FD + elif test -f conftest && test $_lt_result -eq 0 && $GREP forced_load conftest >/dev/null 2>&1 ; then + lt_cv_ld_force_load=yes + else + cat conftest.err >&AS_MESSAGE_LOG_FD + fi + rm -f conftest.err libconftest.a conftest conftest.c + rm -rf conftest.dSYM + ]) + case $host_os in + rhapsody* | darwin1.[[012]]) + _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;; + darwin1.*) + _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;; + darwin*) # darwin 5.x on + # if running on 10.5 or later, the deployment target defaults + # to the OS version, if on x86, and 10.4, the deployment + # target defaults to 10.4. Don't you love it? + case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in + 10.0,*86*-darwin8*|10.0,*-darwin[[91]]*) + _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;; + 10.[[012]]*) + _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;; + 10.*) + _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;; + esac + ;; + esac + if test "$lt_cv_apple_cc_single_mod" = "yes"; then + _lt_dar_single_mod='$single_module' + fi + if test "$lt_cv_ld_exported_symbols_list" = "yes"; then + _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym' + else + _lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}' + fi + if test "$DSYMUTIL" != ":" && test "$lt_cv_ld_force_load" = "no"; then + _lt_dsymutil='~$DSYMUTIL $lib || :' + else + _lt_dsymutil= + fi + ;; + esac +]) + + +# _LT_DARWIN_LINKER_FEATURES([TAG]) +# --------------------------------- +# Checks for linker and compiler features on darwin +m4_defun([_LT_DARWIN_LINKER_FEATURES], +[ + m4_require([_LT_REQUIRED_DARWIN_CHECKS]) + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_automatic, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported + if test "$lt_cv_ld_force_load" = "yes"; then + _LT_TAGVAR(whole_archive_flag_spec, $1)='`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`' + m4_case([$1], [F77], [_LT_TAGVAR(compiler_needs_object, $1)=yes], + [FC], [_LT_TAGVAR(compiler_needs_object, $1)=yes]) + else + _LT_TAGVAR(whole_archive_flag_spec, $1)='' + fi + _LT_TAGVAR(link_all_deplibs, $1)=yes + _LT_TAGVAR(allow_undefined_flag, $1)="$_lt_dar_allow_undefined" + case $cc_basename in + ifort*) _lt_dar_can_shared=yes ;; + *) _lt_dar_can_shared=$GCC ;; + esac + if test "$_lt_dar_can_shared" = "yes"; then + output_verbose_link_cmd=func_echo_all + _LT_TAGVAR(archive_cmds, $1)="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}" + _LT_TAGVAR(module_cmds, $1)="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}" + _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}" + _LT_TAGVAR(module_expsym_cmds, $1)="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}" + m4_if([$1], [CXX], +[ if test "$lt_cv_apple_cc_single_mod" != "yes"; then + _LT_TAGVAR(archive_cmds, $1)="\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dsymutil}" + _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dar_export_syms}${_lt_dsymutil}" + fi +],[]) + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi +]) + +# _LT_SYS_MODULE_PATH_AIX([TAGNAME]) +# ---------------------------------- +# Links a minimal program and checks the executable +# for the system default hardcoded library path. In most cases, +# this is /usr/lib:/lib, but when the MPI compilers are used +# the location of the communication and MPI libs are included too. +# If we don't find anything, use the default library path according +# to the aix ld manual. +# Store the results from the different compilers for each TAGNAME. +# Allow to override them for all tags through lt_cv_aix_libpath. +m4_defun([_LT_SYS_MODULE_PATH_AIX], +[m4_require([_LT_DECL_SED])dnl +if test "${lt_cv_aix_libpath+set}" = set; then + aix_libpath=$lt_cv_aix_libpath +else + AC_CACHE_VAL([_LT_TAGVAR([lt_cv_aix_libpath_], [$1])], + [AC_LINK_IFELSE([AC_LANG_PROGRAM],[ + lt_aix_libpath_sed='[ + /Import File Strings/,/^$/ { + /^0/ { + s/^0 *\([^ ]*\) *$/\1/ + p + } + }]' + _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + # Check for a 64-bit object if we didn't find anything. + if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then + _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + fi],[]) + if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then + _LT_TAGVAR([lt_cv_aix_libpath_], [$1])="/usr/lib:/lib" + fi + ]) + aix_libpath=$_LT_TAGVAR([lt_cv_aix_libpath_], [$1]) +fi +])# _LT_SYS_MODULE_PATH_AIX + + +# _LT_SHELL_INIT(ARG) +# ------------------- +m4_define([_LT_SHELL_INIT], +[m4_divert_text([M4SH-INIT], [$1 +])])# _LT_SHELL_INIT + + + +# _LT_PROG_ECHO_BACKSLASH +# ----------------------- +# Find how we can fake an echo command that does not interpret backslash. +# In particular, with Autoconf 2.60 or later we add some code to the start +# of the generated configure script which will find a shell with a builtin +# printf (which we can use as an echo command). +m4_defun([_LT_PROG_ECHO_BACKSLASH], +[ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO +ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO + +AC_MSG_CHECKING([how to print strings]) +# Test print first, because it will be a builtin if present. +if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \ + test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then + ECHO='print -r --' +elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then + ECHO='printf %s\n' +else + # Use this function as a fallback that always works. + func_fallback_echo () + { + eval 'cat <<_LTECHO_EOF +$[]1 +_LTECHO_EOF' + } + ECHO='func_fallback_echo' +fi + +# func_echo_all arg... +# Invoke $ECHO with all args, space-separated. +func_echo_all () +{ + $ECHO "$*" +} + +case "$ECHO" in + printf*) AC_MSG_RESULT([printf]) ;; + print*) AC_MSG_RESULT([print -r]) ;; + *) AC_MSG_RESULT([cat]) ;; +esac + +m4_ifdef([_AS_DETECT_SUGGESTED], +[_AS_DETECT_SUGGESTED([ + test -n "${ZSH_VERSION+set}${BASH_VERSION+set}" || ( + ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO + ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO + PATH=/empty FPATH=/empty; export PATH FPATH + test "X`printf %s $ECHO`" = "X$ECHO" \ + || test "X`print -r -- $ECHO`" = "X$ECHO" )])]) + +_LT_DECL([], [SHELL], [1], [Shell to use when invoking shell scripts]) +_LT_DECL([], [ECHO], [1], [An echo program that protects backslashes]) +])# _LT_PROG_ECHO_BACKSLASH + + +# _LT_WITH_SYSROOT +# ---------------- +AC_DEFUN([_LT_WITH_SYSROOT], +[AC_MSG_CHECKING([for sysroot]) +AC_ARG_WITH([sysroot], +[ --with-sysroot[=DIR] Search for dependent libraries within DIR + (or the compiler's sysroot if not specified).], +[], [with_sysroot=no]) + +dnl lt_sysroot will always be passed unquoted. We quote it here +dnl in case the user passed a directory name. +lt_sysroot= +case ${with_sysroot} in #( + yes) + if test "$GCC" = yes; then + lt_sysroot=`$CC --print-sysroot 2>/dev/null` + fi + ;; #( + /*) + lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"` + ;; #( + no|'') + ;; #( + *) + AC_MSG_RESULT([${with_sysroot}]) + AC_MSG_ERROR([The sysroot must be an absolute path.]) + ;; +esac + + AC_MSG_RESULT([${lt_sysroot:-no}]) +_LT_DECL([], [lt_sysroot], [0], [The root where to search for ]dnl +[dependent libraries, and in which our libraries should be installed.])]) + +# _LT_ENABLE_LOCK +# --------------- +m4_defun([_LT_ENABLE_LOCK], +[AC_ARG_ENABLE([libtool-lock], + [AS_HELP_STRING([--disable-libtool-lock], + [avoid locking (might break parallel builds)])]) +test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes + +# Some flags need to be propagated to the compiler or linker for good +# libtool support. +case $host in +ia64-*-hpux*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + if AC_TRY_EVAL(ac_compile); then + case `/usr/bin/file conftest.$ac_objext` in + *ELF-32*) + HPUX_IA64_MODE="32" + ;; + *ELF-64*) + HPUX_IA64_MODE="64" + ;; + esac + fi + rm -rf conftest* + ;; +*-*-irix6*) + # Find out which ABI we are using. + echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext + if AC_TRY_EVAL(ac_compile); then + if test "$lt_cv_prog_gnu_ld" = yes; then + case `/usr/bin/file conftest.$ac_objext` in + *32-bit*) + LD="${LD-ld} -melf32bsmip" + ;; + *N32*) + LD="${LD-ld} -melf32bmipn32" + ;; + *64-bit*) + LD="${LD-ld} -melf64bmip" + ;; + esac + else + case `/usr/bin/file conftest.$ac_objext` in + *32-bit*) + LD="${LD-ld} -32" + ;; + *N32*) + LD="${LD-ld} -n32" + ;; + *64-bit*) + LD="${LD-ld} -64" + ;; + esac + fi + fi + rm -rf conftest* + ;; + +x86_64-*kfreebsd*-gnu|x86_64-*linux*|powerpc*-*linux*| \ +s390*-*linux*|s390*-*tpf*|sparc*-*linux*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + if AC_TRY_EVAL(ac_compile); then + case `/usr/bin/file conftest.o` in + *32-bit*) + case $host in + x86_64-*kfreebsd*-gnu) + LD="${LD-ld} -m elf_i386_fbsd" + ;; + x86_64-*linux*) + case `/usr/bin/file conftest.o` in + *x86-64*) + LD="${LD-ld} -m elf32_x86_64" + ;; + *) + LD="${LD-ld} -m elf_i386" + ;; + esac + ;; + powerpc64le-*) + LD="${LD-ld} -m elf32lppclinux" + ;; + powerpc64-*) + LD="${LD-ld} -m elf32ppclinux" + ;; + s390x-*linux*) + LD="${LD-ld} -m elf_s390" + ;; + sparc64-*linux*) + LD="${LD-ld} -m elf32_sparc" + ;; + esac + ;; + *64-bit*) + case $host in + x86_64-*kfreebsd*-gnu) + LD="${LD-ld} -m elf_x86_64_fbsd" + ;; + x86_64-*linux*) + LD="${LD-ld} -m elf_x86_64" + ;; + powerpcle-*) + LD="${LD-ld} -m elf64lppc" + ;; + powerpc-*) + LD="${LD-ld} -m elf64ppc" + ;; + s390*-*linux*|s390*-*tpf*) + LD="${LD-ld} -m elf64_s390" + ;; + sparc*-*linux*) + LD="${LD-ld} -m elf64_sparc" + ;; + esac + ;; + esac + fi + rm -rf conftest* + ;; + +*-*-sco3.2v5*) + # On SCO OpenServer 5, we need -belf to get full-featured binaries. + SAVE_CFLAGS="$CFLAGS" + CFLAGS="$CFLAGS -belf" + AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf, + [AC_LANG_PUSH(C) + AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no]) + AC_LANG_POP]) + if test x"$lt_cv_cc_needs_belf" != x"yes"; then + # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf + CFLAGS="$SAVE_CFLAGS" + fi + ;; +*-*solaris*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + if AC_TRY_EVAL(ac_compile); then + case `/usr/bin/file conftest.o` in + *64-bit*) + case $lt_cv_prog_gnu_ld in + yes*) + case $host in + i?86-*-solaris*) + LD="${LD-ld} -m elf_x86_64" + ;; + sparc*-*-solaris*) + LD="${LD-ld} -m elf64_sparc" + ;; + esac + # GNU ld 2.21 introduced _sol2 emulations. Use them if available. + if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then + LD="${LD-ld}_sol2" + fi + ;; + *) + if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then + LD="${LD-ld} -64" + fi + ;; + esac + ;; + esac + fi + rm -rf conftest* + ;; +esac + +need_locks="$enable_libtool_lock" +])# _LT_ENABLE_LOCK + + +# _LT_PROG_AR +# ----------- +m4_defun([_LT_PROG_AR], +[AC_CHECK_TOOLS(AR, [ar], false) +: ${AR=ar} +: ${AR_FLAGS=cru} +_LT_DECL([], [AR], [1], [The archiver]) +_LT_DECL([], [AR_FLAGS], [1], [Flags to create an archive]) + +AC_CACHE_CHECK([for archiver @FILE support], [lt_cv_ar_at_file], + [lt_cv_ar_at_file=no + AC_COMPILE_IFELSE([AC_LANG_PROGRAM], + [echo conftest.$ac_objext > conftest.lst + lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&AS_MESSAGE_LOG_FD' + AC_TRY_EVAL([lt_ar_try]) + if test "$ac_status" -eq 0; then + # Ensure the archiver fails upon bogus file names. + rm -f conftest.$ac_objext libconftest.a + AC_TRY_EVAL([lt_ar_try]) + if test "$ac_status" -ne 0; then + lt_cv_ar_at_file=@ + fi + fi + rm -f conftest.* libconftest.a + ]) + ]) + +if test "x$lt_cv_ar_at_file" = xno; then + archiver_list_spec= +else + archiver_list_spec=$lt_cv_ar_at_file +fi +_LT_DECL([], [archiver_list_spec], [1], + [How to feed a file listing to the archiver]) +])# _LT_PROG_AR + + +# _LT_CMD_OLD_ARCHIVE +# ------------------- +m4_defun([_LT_CMD_OLD_ARCHIVE], +[_LT_PROG_AR + +AC_CHECK_TOOL(STRIP, strip, :) +test -z "$STRIP" && STRIP=: +_LT_DECL([], [STRIP], [1], [A symbol stripping program]) + +AC_CHECK_TOOL(RANLIB, ranlib, :) +test -z "$RANLIB" && RANLIB=: +_LT_DECL([], [RANLIB], [1], + [Commands used to install an old-style archive]) + +# Determine commands to create old-style static archives. +old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs' +old_postinstall_cmds='chmod 644 $oldlib' +old_postuninstall_cmds= + +if test -n "$RANLIB"; then + case $host_os in + openbsd*) + old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib" + ;; + *) + old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib" + ;; + esac + old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_oldlib" +fi + +case $host_os in + darwin*) + lock_old_archive_extraction=yes ;; + *) + lock_old_archive_extraction=no ;; +esac +_LT_DECL([], [old_postinstall_cmds], [2]) +_LT_DECL([], [old_postuninstall_cmds], [2]) +_LT_TAGDECL([], [old_archive_cmds], [2], + [Commands used to build an old-style archive]) +_LT_DECL([], [lock_old_archive_extraction], [0], + [Whether to use a lock for old archive extraction]) +])# _LT_CMD_OLD_ARCHIVE + + +# _LT_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS, +# [OUTPUT-FILE], [ACTION-SUCCESS], [ACTION-FAILURE]) +# ---------------------------------------------------------------- +# Check whether the given compiler option works +AC_DEFUN([_LT_COMPILER_OPTION], +[m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_DECL_SED])dnl +AC_CACHE_CHECK([$1], [$2], + [$2=no + m4_if([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4]) + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="$3" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&AS_MESSAGE_LOG_FD + echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings other than the usual output. + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then + $2=yes + fi + fi + $RM conftest* +]) + +if test x"[$]$2" = xyes; then + m4_if([$5], , :, [$5]) +else + m4_if([$6], , :, [$6]) +fi +])# _LT_COMPILER_OPTION + +# Old name: +AU_ALIAS([AC_LIBTOOL_COMPILER_OPTION], [_LT_COMPILER_OPTION]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_COMPILER_OPTION], []) + + +# _LT_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS, +# [ACTION-SUCCESS], [ACTION-FAILURE]) +# ---------------------------------------------------- +# Check whether the given linker option works +AC_DEFUN([_LT_LINKER_OPTION], +[m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_DECL_SED])dnl +AC_CACHE_CHECK([$1], [$2], + [$2=no + save_LDFLAGS="$LDFLAGS" + LDFLAGS="$LDFLAGS $3" + echo "$lt_simple_link_test_code" > conftest.$ac_ext + if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then + # The linker can only warn and ignore the option if not recognized + # So say no if there are warnings + if test -s conftest.err; then + # Append any errors to the config.log. + cat conftest.err 1>&AS_MESSAGE_LOG_FD + $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if diff conftest.exp conftest.er2 >/dev/null; then + $2=yes + fi + else + $2=yes + fi + fi + $RM -r conftest* + LDFLAGS="$save_LDFLAGS" +]) + +if test x"[$]$2" = xyes; then + m4_if([$4], , :, [$4]) +else + m4_if([$5], , :, [$5]) +fi +])# _LT_LINKER_OPTION + +# Old name: +AU_ALIAS([AC_LIBTOOL_LINKER_OPTION], [_LT_LINKER_OPTION]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_LINKER_OPTION], []) + + +# LT_CMD_MAX_LEN +#--------------- +AC_DEFUN([LT_CMD_MAX_LEN], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +# find the maximum length of command line arguments +AC_MSG_CHECKING([the maximum length of command line arguments]) +AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl + i=0 + teststring="ABCD" + + case $build_os in + msdosdjgpp*) + # On DJGPP, this test can blow up pretty badly due to problems in libc + # (any single argument exceeding 2000 bytes causes a buffer overrun + # during glob expansion). Even if it were fixed, the result of this + # check would be larger than it should be. + lt_cv_sys_max_cmd_len=12288; # 12K is about right + ;; + + gnu*) + # Under GNU Hurd, this test is not required because there is + # no limit to the length of command line arguments. + # Libtool will interpret -1 as no limit whatsoever + lt_cv_sys_max_cmd_len=-1; + ;; + + cygwin* | mingw* | cegcc*) + # On Win9x/ME, this test blows up -- it succeeds, but takes + # about 5 minutes as the teststring grows exponentially. + # Worse, since 9x/ME are not pre-emptively multitasking, + # you end up with a "frozen" computer, even though with patience + # the test eventually succeeds (with a max line length of 256k). + # Instead, let's just punt: use the minimum linelength reported by + # all of the supported platforms: 8192 (on NT/2K/XP). + lt_cv_sys_max_cmd_len=8192; + ;; + + mint*) + # On MiNT this can take a long time and run out of memory. + lt_cv_sys_max_cmd_len=8192; + ;; + + amigaos*) + # On AmigaOS with pdksh, this test takes hours, literally. + # So we just punt and use a minimum line length of 8192. + lt_cv_sys_max_cmd_len=8192; + ;; + + netbsd* | freebsd* | openbsd* | darwin* | dragonfly*) + # This has been around since 386BSD, at least. Likely further. + if test -x /sbin/sysctl; then + lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax` + elif test -x /usr/sbin/sysctl; then + lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax` + else + lt_cv_sys_max_cmd_len=65536 # usable default for all BSDs + fi + # And add a safety zone + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` + ;; + + interix*) + # We know the value 262144 and hardcode it with a safety zone (like BSD) + lt_cv_sys_max_cmd_len=196608 + ;; + + os2*) + # The test takes a long time on OS/2. + lt_cv_sys_max_cmd_len=8192 + ;; + + osf*) + # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure + # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not + # nice to cause kernel panics so lets avoid the loop below. + # First set a reasonable default. + lt_cv_sys_max_cmd_len=16384 + # + if test -x /sbin/sysconfig; then + case `/sbin/sysconfig -q proc exec_disable_arg_limit` in + *1*) lt_cv_sys_max_cmd_len=-1 ;; + esac + fi + ;; + sco3.2v5*) + lt_cv_sys_max_cmd_len=102400 + ;; + sysv5* | sco5v6* | sysv4.2uw2*) + kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null` + if test -n "$kargmax"; then + lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[[ ]]//'` + else + lt_cv_sys_max_cmd_len=32768 + fi + ;; + *) + lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null` + if test -n "$lt_cv_sys_max_cmd_len" && \ + test undefined != "$lt_cv_sys_max_cmd_len"; then + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` + else + # Make teststring a little bigger before we do anything with it. + # a 1K string should be a reasonable start. + for i in 1 2 3 4 5 6 7 8 ; do + teststring=$teststring$teststring + done + SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}} + # If test is not a shell built-in, we'll probably end up computing a + # maximum length that is only half of the actual maximum length, but + # we can't tell. + while { test "X"`env echo "$teststring$teststring" 2>/dev/null` \ + = "X$teststring$teststring"; } >/dev/null 2>&1 && + test $i != 17 # 1/2 MB should be enough + do + i=`expr $i + 1` + teststring=$teststring$teststring + done + # Only check the string length outside the loop. + lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1` + teststring= + # Add a significant safety factor because C++ compilers can tack on + # massive amounts of additional arguments before passing them to the + # linker. It appears as though 1/2 is a usable value. + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2` + fi + ;; + esac +]) +if test -n $lt_cv_sys_max_cmd_len ; then + AC_MSG_RESULT($lt_cv_sys_max_cmd_len) +else + AC_MSG_RESULT(none) +fi +max_cmd_len=$lt_cv_sys_max_cmd_len +_LT_DECL([], [max_cmd_len], [0], + [What is the maximum length of a command?]) +])# LT_CMD_MAX_LEN + +# Old name: +AU_ALIAS([AC_LIBTOOL_SYS_MAX_CMD_LEN], [LT_CMD_MAX_LEN]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN], []) + + +# _LT_HEADER_DLFCN +# ---------------- +m4_defun([_LT_HEADER_DLFCN], +[AC_CHECK_HEADERS([dlfcn.h], [], [], [AC_INCLUDES_DEFAULT])dnl +])# _LT_HEADER_DLFCN + + +# _LT_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE, +# ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING) +# ---------------------------------------------------------------- +m4_defun([_LT_TRY_DLOPEN_SELF], +[m4_require([_LT_HEADER_DLFCN])dnl +if test "$cross_compiling" = yes; then : + [$4] +else + lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 + lt_status=$lt_dlunknown + cat > conftest.$ac_ext <<_LT_EOF +[#line $LINENO "configure" +#include "confdefs.h" + +#if HAVE_DLFCN_H +#include +#endif + +#include + +#ifdef RTLD_GLOBAL +# define LT_DLGLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_DLGLOBAL DL_GLOBAL +# else +# define LT_DLGLOBAL 0 +# endif +#endif + +/* We may have to define LT_DLLAZY_OR_NOW in the command line if we + find out it does not work in some platform. */ +#ifndef LT_DLLAZY_OR_NOW +# ifdef RTLD_LAZY +# define LT_DLLAZY_OR_NOW RTLD_LAZY +# else +# ifdef DL_LAZY +# define LT_DLLAZY_OR_NOW DL_LAZY +# else +# ifdef RTLD_NOW +# define LT_DLLAZY_OR_NOW RTLD_NOW +# else +# ifdef DL_NOW +# define LT_DLLAZY_OR_NOW DL_NOW +# else +# define LT_DLLAZY_OR_NOW 0 +# endif +# endif +# endif +# endif +#endif + +/* When -fvisbility=hidden is used, assume the code has been annotated + correspondingly for the symbols needed. */ +#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)) +int fnord () __attribute__((visibility("default"))); +#endif + +int fnord () { return 42; } +int main () +{ + void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); + int status = $lt_dlunknown; + + if (self) + { + if (dlsym (self,"fnord")) status = $lt_dlno_uscore; + else + { + if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; + else puts (dlerror ()); + } + /* dlclose (self); */ + } + else + puts (dlerror ()); + + return status; +}] +_LT_EOF + if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} 2>/dev/null; then + (./conftest; exit; ) >&AS_MESSAGE_LOG_FD 2>/dev/null + lt_status=$? + case x$lt_status in + x$lt_dlno_uscore) $1 ;; + x$lt_dlneed_uscore) $2 ;; + x$lt_dlunknown|x*) $3 ;; + esac + else : + # compilation failed + $3 + fi +fi +rm -fr conftest* +])# _LT_TRY_DLOPEN_SELF + + +# LT_SYS_DLOPEN_SELF +# ------------------ +AC_DEFUN([LT_SYS_DLOPEN_SELF], +[m4_require([_LT_HEADER_DLFCN])dnl +if test "x$enable_dlopen" != xyes; then + enable_dlopen=unknown + enable_dlopen_self=unknown + enable_dlopen_self_static=unknown +else + lt_cv_dlopen=no + lt_cv_dlopen_libs= + + case $host_os in + beos*) + lt_cv_dlopen="load_add_on" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + ;; + + mingw* | pw32* | cegcc*) + lt_cv_dlopen="LoadLibrary" + lt_cv_dlopen_libs= + ;; + + cygwin*) + lt_cv_dlopen="dlopen" + lt_cv_dlopen_libs= + ;; + + darwin*) + # if libdl is installed we need to link against it + AC_CHECK_LIB([dl], [dlopen], + [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],[ + lt_cv_dlopen="dyld" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + ]) + ;; + + *) + AC_CHECK_FUNC([shl_load], + [lt_cv_dlopen="shl_load"], + [AC_CHECK_LIB([dld], [shl_load], + [lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld"], + [AC_CHECK_FUNC([dlopen], + [lt_cv_dlopen="dlopen"], + [AC_CHECK_LIB([dl], [dlopen], + [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"], + [AC_CHECK_LIB([svld], [dlopen], + [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"], + [AC_CHECK_LIB([dld], [dld_link], + [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld"]) + ]) + ]) + ]) + ]) + ]) + ;; + esac + + if test "x$lt_cv_dlopen" != xno; then + enable_dlopen=yes + else + enable_dlopen=no + fi + + case $lt_cv_dlopen in + dlopen) + save_CPPFLAGS="$CPPFLAGS" + test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H" + + save_LDFLAGS="$LDFLAGS" + wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\" + + save_LIBS="$LIBS" + LIBS="$lt_cv_dlopen_libs $LIBS" + + AC_CACHE_CHECK([whether a program can dlopen itself], + lt_cv_dlopen_self, [dnl + _LT_TRY_DLOPEN_SELF( + lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes, + lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross) + ]) + + if test "x$lt_cv_dlopen_self" = xyes; then + wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\" + AC_CACHE_CHECK([whether a statically linked program can dlopen itself], + lt_cv_dlopen_self_static, [dnl + _LT_TRY_DLOPEN_SELF( + lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes, + lt_cv_dlopen_self_static=no, lt_cv_dlopen_self_static=cross) + ]) + fi + + CPPFLAGS="$save_CPPFLAGS" + LDFLAGS="$save_LDFLAGS" + LIBS="$save_LIBS" + ;; + esac + + case $lt_cv_dlopen_self in + yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;; + *) enable_dlopen_self=unknown ;; + esac + + case $lt_cv_dlopen_self_static in + yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;; + *) enable_dlopen_self_static=unknown ;; + esac +fi +_LT_DECL([dlopen_support], [enable_dlopen], [0], + [Whether dlopen is supported]) +_LT_DECL([dlopen_self], [enable_dlopen_self], [0], + [Whether dlopen of programs is supported]) +_LT_DECL([dlopen_self_static], [enable_dlopen_self_static], [0], + [Whether dlopen of statically linked programs is supported]) +])# LT_SYS_DLOPEN_SELF + +# Old name: +AU_ALIAS([AC_LIBTOOL_DLOPEN_SELF], [LT_SYS_DLOPEN_SELF]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF], []) + + +# _LT_COMPILER_C_O([TAGNAME]) +# --------------------------- +# Check to see if options -c and -o are simultaneously supported by compiler. +# This macro does not hard code the compiler like AC_PROG_CC_C_O. +m4_defun([_LT_COMPILER_C_O], +[m4_require([_LT_DECL_SED])dnl +m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_TAG_COMPILER])dnl +AC_CACHE_CHECK([if $compiler supports -c -o file.$ac_objext], + [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)], + [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=no + $RM -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&AS_MESSAGE_LOG_FD + echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp + $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 + if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then + _LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes + fi + fi + chmod u+w . 2>&AS_MESSAGE_LOG_FD + $RM conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files + $RM out/* && rmdir out + cd .. + $RM -r conftest + $RM conftest* +]) +_LT_TAGDECL([compiler_c_o], [lt_cv_prog_compiler_c_o], [1], + [Does compiler simultaneously support -c and -o options?]) +])# _LT_COMPILER_C_O + + +# _LT_COMPILER_FILE_LOCKS([TAGNAME]) +# ---------------------------------- +# Check to see if we can do hard links to lock some files if needed +m4_defun([_LT_COMPILER_FILE_LOCKS], +[m4_require([_LT_ENABLE_LOCK])dnl +m4_require([_LT_FILEUTILS_DEFAULTS])dnl +_LT_COMPILER_C_O([$1]) + +hard_links="nottested" +if test "$_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)" = no && test "$need_locks" != no; then + # do not overwrite the value of need_locks provided by the user + AC_MSG_CHECKING([if we can lock with hard links]) + hard_links=yes + $RM conftest* + ln conftest.a conftest.b 2>/dev/null && hard_links=no + touch conftest.a + ln conftest.a conftest.b 2>&5 || hard_links=no + ln conftest.a conftest.b 2>/dev/null && hard_links=no + AC_MSG_RESULT([$hard_links]) + if test "$hard_links" = no; then + AC_MSG_WARN([`$CC' does not support `-c -o', so `make -j' may be unsafe]) + need_locks=warn + fi +else + need_locks=no +fi +_LT_DECL([], [need_locks], [1], [Must we lock files when doing compilation?]) +])# _LT_COMPILER_FILE_LOCKS + + +# _LT_CHECK_OBJDIR +# ---------------- +m4_defun([_LT_CHECK_OBJDIR], +[AC_CACHE_CHECK([for objdir], [lt_cv_objdir], +[rm -f .libs 2>/dev/null +mkdir .libs 2>/dev/null +if test -d .libs; then + lt_cv_objdir=.libs +else + # MS-DOS does not allow filenames that begin with a dot. + lt_cv_objdir=_libs +fi +rmdir .libs 2>/dev/null]) +objdir=$lt_cv_objdir +_LT_DECL([], [objdir], [0], + [The name of the directory that contains temporary libtool files])dnl +m4_pattern_allow([LT_OBJDIR])dnl +AC_DEFINE_UNQUOTED(LT_OBJDIR, "$lt_cv_objdir/", + [Define to the sub-directory in which libtool stores uninstalled libraries.]) +])# _LT_CHECK_OBJDIR + + +# _LT_LINKER_HARDCODE_LIBPATH([TAGNAME]) +# -------------------------------------- +# Check hardcoding attributes. +m4_defun([_LT_LINKER_HARDCODE_LIBPATH], +[AC_MSG_CHECKING([how to hardcode library paths into programs]) +_LT_TAGVAR(hardcode_action, $1)= +if test -n "$_LT_TAGVAR(hardcode_libdir_flag_spec, $1)" || + test -n "$_LT_TAGVAR(runpath_var, $1)" || + test "X$_LT_TAGVAR(hardcode_automatic, $1)" = "Xyes" ; then + + # We can hardcode non-existent directories. + if test "$_LT_TAGVAR(hardcode_direct, $1)" != no && + # If the only mechanism to avoid hardcoding is shlibpath_var, we + # have to relink, otherwise we might link with an installed library + # when we should be linking with a yet-to-be-installed one + ## test "$_LT_TAGVAR(hardcode_shlibpath_var, $1)" != no && + test "$_LT_TAGVAR(hardcode_minus_L, $1)" != no; then + # Linking always hardcodes the temporary library directory. + _LT_TAGVAR(hardcode_action, $1)=relink + else + # We can link without hardcoding, and we can hardcode nonexisting dirs. + _LT_TAGVAR(hardcode_action, $1)=immediate + fi +else + # We cannot hardcode anything, or else we can only hardcode existing + # directories. + _LT_TAGVAR(hardcode_action, $1)=unsupported +fi +AC_MSG_RESULT([$_LT_TAGVAR(hardcode_action, $1)]) + +if test "$_LT_TAGVAR(hardcode_action, $1)" = relink || + test "$_LT_TAGVAR(inherit_rpath, $1)" = yes; then + # Fast installation is not supported + enable_fast_install=no +elif test "$shlibpath_overrides_runpath" = yes || + test "$enable_shared" = no; then + # Fast installation is not necessary + enable_fast_install=needless +fi +_LT_TAGDECL([], [hardcode_action], [0], + [How to hardcode a shared library path into an executable]) +])# _LT_LINKER_HARDCODE_LIBPATH + + +# _LT_CMD_STRIPLIB +# ---------------- +m4_defun([_LT_CMD_STRIPLIB], +[m4_require([_LT_DECL_EGREP]) +striplib= +old_striplib= +AC_MSG_CHECKING([whether stripping libraries is possible]) +if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then + test -z "$old_striplib" && old_striplib="$STRIP --strip-debug" + test -z "$striplib" && striplib="$STRIP --strip-unneeded" + AC_MSG_RESULT([yes]) +else +# FIXME - insert some real tests, host_os isn't really good enough + case $host_os in + darwin*) + if test -n "$STRIP" ; then + striplib="$STRIP -x" + old_striplib="$STRIP -S" + AC_MSG_RESULT([yes]) + else + AC_MSG_RESULT([no]) + fi + ;; + *) + AC_MSG_RESULT([no]) + ;; + esac +fi +_LT_DECL([], [old_striplib], [1], [Commands to strip libraries]) +_LT_DECL([], [striplib], [1]) +])# _LT_CMD_STRIPLIB + + +# _LT_SYS_DYNAMIC_LINKER([TAG]) +# ----------------------------- +# PORTME Fill in your ld.so characteristics +m4_defun([_LT_SYS_DYNAMIC_LINKER], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +m4_require([_LT_DECL_EGREP])dnl +m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_DECL_OBJDUMP])dnl +m4_require([_LT_DECL_SED])dnl +m4_require([_LT_CHECK_SHELL_FEATURES])dnl +AC_MSG_CHECKING([dynamic linker characteristics]) +m4_if([$1], + [], [ +if test "$GCC" = yes; then + case $host_os in + darwin*) lt_awk_arg="/^libraries:/,/LR/" ;; + *) lt_awk_arg="/^libraries:/" ;; + esac + case $host_os in + mingw* | cegcc*) lt_sed_strip_eq="s,=\([[A-Za-z]]:\),\1,g" ;; + *) lt_sed_strip_eq="s,=/,/,g" ;; + esac + lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq` + case $lt_search_path_spec in + *\;*) + # if the path contains ";" then we assume it to be the separator + # otherwise default to the standard path separator (i.e. ":") - it is + # assumed that no part of a normal pathname contains ";" but that should + # okay in the real world where ";" in dirpaths is itself problematic. + lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED 's/;/ /g'` + ;; + *) + lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED "s/$PATH_SEPARATOR/ /g"` + ;; + esac + # Ok, now we have the path, separated by spaces, we can step through it + # and add multilib dir if necessary. + lt_tmp_lt_search_path_spec= + lt_multi_os_dir=`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null` + for lt_sys_path in $lt_search_path_spec; do + if test -d "$lt_sys_path/$lt_multi_os_dir"; then + lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path/$lt_multi_os_dir" + else + test -d "$lt_sys_path" && \ + lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path" + fi + done + lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk ' +BEGIN {RS=" "; FS="/|\n";} { + lt_foo=""; + lt_count=0; + for (lt_i = NF; lt_i > 0; lt_i--) { + if ($lt_i != "" && $lt_i != ".") { + if ($lt_i == "..") { + lt_count++; + } else { + if (lt_count == 0) { + lt_foo="/" $lt_i lt_foo; + } else { + lt_count--; + } + } + } + } + if (lt_foo != "") { lt_freq[[lt_foo]]++; } + if (lt_freq[[lt_foo]] == 1) { print lt_foo; } +}'` + # AWK program above erroneously prepends '/' to C:/dos/paths + # for these hosts. + case $host_os in + mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\ + $SED 's,/\([[A-Za-z]]:\),\1,g'` ;; + esac + sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP` +else + sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" +fi]) +library_names_spec= +libname_spec='lib$name' +soname_spec= +shrext_cmds=".so" +postinstall_cmds= +postuninstall_cmds= +finish_cmds= +finish_eval= +shlibpath_var= +shlibpath_overrides_runpath=unknown +version_type=none +dynamic_linker="$host_os ld.so" +sys_lib_dlsearch_path_spec="/lib /usr/lib" +need_lib_prefix=unknown +hardcode_into_libs=no + +# when you set need_version to no, make sure it does not cause -set_version +# flags to be left without arguments +need_version=unknown + +case $host_os in +aix3*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' + shlibpath_var=LIBPATH + + # AIX 3 has no versioning support, so we append a major version to the name. + soname_spec='${libname}${release}${shared_ext}$major' + ;; + +aix[[4-9]]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + hardcode_into_libs=yes + if test "$host_cpu" = ia64; then + # AIX 5 supports IA64 + library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + else + # With GCC up to 2.95.x, collect2 would create an import file + # for dependence libraries. The import file would start with + # the line `#! .'. This would cause the generated library to + # depend on `.', always an invalid library. This was fixed in + # development snapshots of GCC prior to 3.0. + case $host_os in + aix4 | aix4.[[01]] | aix4.[[01]].*) + if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' + echo ' yes ' + echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then + : + else + can_build_shared=no + fi + ;; + esac + # AIX (on Power*) has no versioning support, so currently we can not hardcode correct + # soname into executable. Probably we can add versioning support to + # collect2, so additional links can be useful in future. + if test "$aix_use_runtimelinking" = yes; then + # If using run time linking (on AIX 4.2 or later) use lib.so + # instead of lib.a to let people know that these are not + # typical AIX shared libraries. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + else + # We preserve .a as extension for shared libraries through AIX4.2 + # and later when we are not doing run time linking. + library_names_spec='${libname}${release}.a $libname.a' + soname_spec='${libname}${release}${shared_ext}$major' + fi + shlibpath_var=LIBPATH + fi + ;; + +amigaos*) + case $host_cpu in + powerpc) + # Since July 2007 AmigaOS4 officially supports .so libraries. + # When compiling the executable, add -use-dynld -Lsobjs: to the compileline. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + ;; + m68k) + library_names_spec='$libname.ixlibrary $libname.a' + # Create ${libname}_ixlibrary.a entries in /sys/libs. + finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([[^/]]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' + ;; + esac + ;; + +beos*) + library_names_spec='${libname}${shared_ext}' + dynamic_linker="$host_os ld.so" + shlibpath_var=LIBRARY_PATH + ;; + +bsdi[[45]]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" + sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" + # the default ld.so.conf also contains /usr/contrib/lib and + # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow + # libtool to hard-code these into programs + ;; + +cygwin* | mingw* | pw32* | cegcc*) + version_type=windows + shrext_cmds=".dll" + need_version=no + need_lib_prefix=no + + case $GCC,$cc_basename in + yes,*) + # gcc + library_names_spec='$libname.dll.a' + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname~ + chmod a+x \$dldir/$dlname~ + if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then + eval '\''$striplib \$dldir/$dlname'\'' || exit \$?; + fi' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $RM \$dlpath' + shlibpath_overrides_runpath=yes + + case $host_os in + cygwin*) + # Cygwin DLLs use 'cyg' prefix rather than 'lib' + soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' +m4_if([$1], [],[ + sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"]) + ;; + mingw* | cegcc*) + # MinGW DLLs use traditional 'lib' prefix + soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' + ;; + pw32*) + # pw32 DLLs use 'pw' prefix rather than 'lib' + library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' + ;; + esac + dynamic_linker='Win32 ld.exe' + ;; + + *,cl*) + # Native MSVC + libname_spec='$name' + soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' + library_names_spec='${libname}.dll.lib' + + case $build_os in + mingw*) + sys_lib_search_path_spec= + lt_save_ifs=$IFS + IFS=';' + for lt_path in $LIB + do + IFS=$lt_save_ifs + # Let DOS variable expansion print the short 8.3 style file name. + lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"` + sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path" + done + IFS=$lt_save_ifs + # Convert to MSYS style. + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([[a-zA-Z]]\\):| /\\1|g' -e 's|^ ||'` + ;; + cygwin*) + # Convert to unix form, then to dos form, then back to unix form + # but this time dos style (no spaces!) so that the unix form looks + # like /cygdrive/c/PROGRA~1:/cygdr... + sys_lib_search_path_spec=`cygpath --path --unix "$LIB"` + sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null` + sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + ;; + *) + sys_lib_search_path_spec="$LIB" + if $ECHO "$sys_lib_search_path_spec" | [$GREP ';[c-zC-Z]:/' >/dev/null]; then + # It is most probably a Windows format PATH. + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi + # FIXME: find the short name or the path components, as spaces are + # common. (e.g. "Program Files" -> "PROGRA~1") + ;; + esac + + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $RM \$dlpath' + shlibpath_overrides_runpath=yes + dynamic_linker='Win32 link.exe' + ;; + + *) + # Assume MSVC wrapper + library_names_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext} $libname.lib' + dynamic_linker='Win32 ld.exe' + ;; + esac + # FIXME: first we should search . and the directory the executable is in + shlibpath_var=PATH + ;; + +darwin* | rhapsody*) + dynamic_linker="$host_os dyld" + version_type=darwin + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext' + soname_spec='${libname}${release}${major}$shared_ext' + shlibpath_overrides_runpath=yes + shlibpath_var=DYLD_LIBRARY_PATH + shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`' +m4_if([$1], [],[ + sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib"]) + sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib' + ;; + +dgux*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +freebsd* | dragonfly*) + # DragonFly does not have aout. When/if they implement a new + # versioning mechanism, adjust this. + if test -x /usr/bin/objformat; then + objformat=`/usr/bin/objformat` + else + case $host_os in + freebsd[[23]].*) objformat=aout ;; + *) objformat=elf ;; + esac + fi + version_type=freebsd-$objformat + case $version_type in + freebsd-elf*) + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + need_version=no + need_lib_prefix=no + ;; + freebsd-*) + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' + need_version=yes + ;; + esac + shlibpath_var=LD_LIBRARY_PATH + case $host_os in + freebsd2.*) + shlibpath_overrides_runpath=yes + ;; + freebsd3.[[01]]* | freebsdelf3.[[01]]*) + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + freebsd3.[[2-9]]* | freebsdelf3.[[2-9]]* | \ + freebsd4.[[0-5]] | freebsdelf4.[[0-5]] | freebsd4.1.1 | freebsdelf4.1.1) + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + *) # from 4.6 on, and DragonFly + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + esac + ;; + +haiku*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + dynamic_linker="$host_os runtime_loader" + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LIBRARY_PATH + shlibpath_overrides_runpath=yes + sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib' + hardcode_into_libs=yes + ;; + +hpux9* | hpux10* | hpux11*) + # Give a soname corresponding to the major version so that dld.sl refuses to + # link against other versions. + version_type=sunos + need_lib_prefix=no + need_version=no + case $host_cpu in + ia64*) + shrext_cmds='.so' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.so" + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + if test "X$HPUX_IA64_MODE" = X32; then + sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" + else + sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" + fi + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + hppa*64*) + shrext_cmds='.sl' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.sl" + shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + *) + shrext_cmds='.sl' + dynamic_linker="$host_os dld.sl" + shlibpath_var=SHLIB_PATH + shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + ;; + esac + # HP-UX runs *really* slowly unless shared libraries are mode 555, ... + postinstall_cmds='chmod 555 $lib' + # or fails outright, so override atomically: + install_override_mode=555 + ;; + +interix[[3-9]]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + +irix5* | irix6* | nonstopux*) + case $host_os in + nonstopux*) version_type=nonstopux ;; + *) + if test "$lt_cv_prog_gnu_ld" = yes; then + version_type=linux # correct to gnu/linux during the next big refactor + else + version_type=irix + fi ;; + esac + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' + case $host_os in + irix5* | nonstopux*) + libsuff= shlibsuff= + ;; + *) + case $LD in # libtool.m4 will add one of these switches to LD + *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") + libsuff= shlibsuff= libmagic=32-bit;; + *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") + libsuff=32 shlibsuff=N32 libmagic=N32;; + *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") + libsuff=64 shlibsuff=64 libmagic=64-bit;; + *) libsuff= shlibsuff= libmagic=never-match;; + esac + ;; + esac + shlibpath_var=LD_LIBRARY${shlibsuff}_PATH + shlibpath_overrides_runpath=no + sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" + sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" + hardcode_into_libs=yes + ;; + +# No shared lib support for Linux oldld, aout, or coff. +linux*oldld* | linux*aout* | linux*coff*) + dynamic_linker=no + ;; + +# This must be glibc/ELF. +linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + + # Some binutils ld are patched to set DT_RUNPATH + AC_CACHE_VAL([lt_cv_shlibpath_overrides_runpath], + [lt_cv_shlibpath_overrides_runpath=no + save_LDFLAGS=$LDFLAGS + save_libdir=$libdir + eval "libdir=/foo; wl=\"$_LT_TAGVAR(lt_prog_compiler_wl, $1)\"; \ + LDFLAGS=\"\$LDFLAGS $_LT_TAGVAR(hardcode_libdir_flag_spec, $1)\"" + AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], + [AS_IF([ ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null], + [lt_cv_shlibpath_overrides_runpath=yes])]) + LDFLAGS=$save_LDFLAGS + libdir=$save_libdir + ]) + shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath + + # This implies no fast_install, which is unacceptable. + # Some rework will be needed to allow for fast_install + # before this can be enabled. + hardcode_into_libs=yes + + # Append ld.so.conf contents to the search path + if test -f /etc/ld.so.conf; then + lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \[$]2)); skip = 1; } { if (!skip) print \[$]0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '` + sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra" + fi + + # We used to test for /lib/ld.so.1 and disable shared libraries on + # powerpc, because MkLinux only supported shared libraries with the + # GNU dynamic linker. Since this was broken with cross compilers, + # most powerpc-linux boxes support dynamic linking these days and + # people can always --disable-shared, the test was removed, and we + # assume the GNU/Linux dynamic linker is in use. + dynamic_linker='GNU/Linux ld.so' + ;; + +netbsdelf*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='NetBSD ld.elf_so' + ;; + +netbsd*) + version_type=sunos + need_lib_prefix=no + need_version=no + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + dynamic_linker='NetBSD (a.out) ld.so' + else + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='NetBSD ld.elf_so' + fi + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + +newsos6) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +*nto* | *qnx*) + version_type=qnx + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='ldqnx.so' + ;; + +openbsd*) + version_type=sunos + sys_lib_dlsearch_path_spec="/usr/lib" + need_lib_prefix=no + # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs. + case $host_os in + openbsd3.3 | openbsd3.3.*) need_version=yes ;; + *) need_version=no ;; + esac + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + shlibpath_var=LD_LIBRARY_PATH + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + case $host_os in + openbsd2.[[89]] | openbsd2.[[89]].*) + shlibpath_overrides_runpath=no + ;; + *) + shlibpath_overrides_runpath=yes + ;; + esac + else + shlibpath_overrides_runpath=yes + fi + ;; + +os2*) + libname_spec='$name' + shrext_cmds=".dll" + need_lib_prefix=no + library_names_spec='$libname${shared_ext} $libname.a' + dynamic_linker='OS/2 ld.exe' + shlibpath_var=LIBPATH + ;; + +osf3* | osf4* | osf5*) + version_type=osf + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" + sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" + ;; + +rdos*) + dynamic_linker=no + ;; + +solaris*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + # ldd complains unless libraries are executable + postinstall_cmds='chmod +x $lib' + ;; + +sunos4*) + version_type=sunos + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + if test "$with_gnu_ld" = yes; then + need_lib_prefix=no + fi + need_version=yes + ;; + +sysv4 | sysv4.3*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + case $host_vendor in + sni) + shlibpath_overrides_runpath=no + need_lib_prefix=no + runpath_var=LD_RUN_PATH + ;; + siemens) + need_lib_prefix=no + ;; + motorola) + need_lib_prefix=no + need_version=no + shlibpath_overrides_runpath=no + sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' + ;; + esac + ;; + +sysv4*MP*) + if test -d /usr/nec ;then + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' + soname_spec='$libname${shared_ext}.$major' + shlibpath_var=LD_LIBRARY_PATH + fi + ;; + +sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) + version_type=freebsd-elf + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + if test "$with_gnu_ld" = yes; then + sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib' + else + sys_lib_search_path_spec='/usr/ccs/lib /usr/lib' + case $host_os in + sco3.2v5*) + sys_lib_search_path_spec="$sys_lib_search_path_spec /lib" + ;; + esac + fi + sys_lib_dlsearch_path_spec='/usr/lib' + ;; + +tpf*) + # TPF is a cross-target only. Preferred cross-host = GNU/Linux. + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + +uts4*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +*) + dynamic_linker=no + ;; +esac +AC_MSG_RESULT([$dynamic_linker]) +test "$dynamic_linker" = no && can_build_shared=no + +variables_saved_for_relink="PATH $shlibpath_var $runpath_var" +if test "$GCC" = yes; then + variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" +fi + +if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then + sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec" +fi +if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then + sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec" +fi + +_LT_DECL([], [variables_saved_for_relink], [1], + [Variables whose values should be saved in libtool wrapper scripts and + restored at link time]) +_LT_DECL([], [need_lib_prefix], [0], + [Do we need the "lib" prefix for modules?]) +_LT_DECL([], [need_version], [0], [Do we need a version for libraries?]) +_LT_DECL([], [version_type], [0], [Library versioning type]) +_LT_DECL([], [runpath_var], [0], [Shared library runtime path variable]) +_LT_DECL([], [shlibpath_var], [0],[Shared library path variable]) +_LT_DECL([], [shlibpath_overrides_runpath], [0], + [Is shlibpath searched before the hard-coded library search path?]) +_LT_DECL([], [libname_spec], [1], [Format of library name prefix]) +_LT_DECL([], [library_names_spec], [1], + [[List of archive names. First name is the real one, the rest are links. + The last name is the one that the linker finds with -lNAME]]) +_LT_DECL([], [soname_spec], [1], + [[The coded name of the library, if different from the real name]]) +_LT_DECL([], [install_override_mode], [1], + [Permission mode override for installation of shared libraries]) +_LT_DECL([], [postinstall_cmds], [2], + [Command to use after installation of a shared archive]) +_LT_DECL([], [postuninstall_cmds], [2], + [Command to use after uninstallation of a shared archive]) +_LT_DECL([], [finish_cmds], [2], + [Commands used to finish a libtool library installation in a directory]) +_LT_DECL([], [finish_eval], [1], + [[As "finish_cmds", except a single script fragment to be evaled but + not shown]]) +_LT_DECL([], [hardcode_into_libs], [0], + [Whether we should hardcode library paths into libraries]) +_LT_DECL([], [sys_lib_search_path_spec], [2], + [Compile-time system search path for libraries]) +_LT_DECL([], [sys_lib_dlsearch_path_spec], [2], + [Run-time system search path for libraries]) +])# _LT_SYS_DYNAMIC_LINKER + + +# _LT_PATH_TOOL_PREFIX(TOOL) +# -------------------------- +# find a file program which can recognize shared library +AC_DEFUN([_LT_PATH_TOOL_PREFIX], +[m4_require([_LT_DECL_EGREP])dnl +AC_MSG_CHECKING([for $1]) +AC_CACHE_VAL(lt_cv_path_MAGIC_CMD, +[case $MAGIC_CMD in +[[\\/*] | ?:[\\/]*]) + lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. + ;; +*) + lt_save_MAGIC_CMD="$MAGIC_CMD" + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR +dnl $ac_dummy forces splitting on constant user-supplied paths. +dnl POSIX.2 word splitting is done only on the output of word expansions, +dnl not every word. This closes a longstanding sh security hole. + ac_dummy="m4_if([$2], , $PATH, [$2])" + for ac_dir in $ac_dummy; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$1; then + lt_cv_path_MAGIC_CMD="$ac_dir/$1" + if test -n "$file_magic_test_file"; then + case $deplibs_check_method in + "file_magic "*) + file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"` + MAGIC_CMD="$lt_cv_path_MAGIC_CMD" + if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | + $EGREP "$file_magic_regex" > /dev/null; then + : + else + cat <<_LT_EOF 1>&2 + +*** Warning: the command libtool uses to detect shared libraries, +*** $file_magic_cmd, produces output that libtool cannot recognize. +*** The result is that libtool may fail to recognize shared libraries +*** as such. This will affect the creation of libtool libraries that +*** depend on shared libraries, but programs linked with such libtool +*** libraries will work regardless of this problem. Nevertheless, you +*** may want to report the problem to your system manager and/or to +*** bug-libtool@gnu.org + +_LT_EOF + fi ;; + esac + fi + break + fi + done + IFS="$lt_save_ifs" + MAGIC_CMD="$lt_save_MAGIC_CMD" + ;; +esac]) +MAGIC_CMD="$lt_cv_path_MAGIC_CMD" +if test -n "$MAGIC_CMD"; then + AC_MSG_RESULT($MAGIC_CMD) +else + AC_MSG_RESULT(no) +fi +_LT_DECL([], [MAGIC_CMD], [0], + [Used to examine libraries when file_magic_cmd begins with "file"])dnl +])# _LT_PATH_TOOL_PREFIX + +# Old name: +AU_ALIAS([AC_PATH_TOOL_PREFIX], [_LT_PATH_TOOL_PREFIX]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_PATH_TOOL_PREFIX], []) + + +# _LT_PATH_MAGIC +# -------------- +# find a file program which can recognize a shared library +m4_defun([_LT_PATH_MAGIC], +[_LT_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin$PATH_SEPARATOR$PATH) +if test -z "$lt_cv_path_MAGIC_CMD"; then + if test -n "$ac_tool_prefix"; then + _LT_PATH_TOOL_PREFIX(file, /usr/bin$PATH_SEPARATOR$PATH) + else + MAGIC_CMD=: + fi +fi +])# _LT_PATH_MAGIC + + +# LT_PATH_LD +# ---------- +# find the pathname to the GNU or non-GNU linker +AC_DEFUN([LT_PATH_LD], +[AC_REQUIRE([AC_PROG_CC])dnl +AC_REQUIRE([AC_CANONICAL_HOST])dnl +AC_REQUIRE([AC_CANONICAL_BUILD])dnl +m4_require([_LT_DECL_SED])dnl +m4_require([_LT_DECL_EGREP])dnl +m4_require([_LT_PROG_ECHO_BACKSLASH])dnl + +AC_ARG_WITH([gnu-ld], + [AS_HELP_STRING([--with-gnu-ld], + [assume the C compiler uses GNU ld @<:@default=no@:>@])], + [test "$withval" = no || with_gnu_ld=yes], + [with_gnu_ld=no])dnl + +ac_prog=ld +if test "$GCC" = yes; then + # Check if gcc -print-prog-name=ld gives a path. + AC_MSG_CHECKING([for ld used by $CC]) + case $host in + *-*-mingw*) + # gcc leaves a trailing carriage return which upsets mingw + ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; + *) + ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; + esac + case $ac_prog in + # Accept absolute paths. + [[\\/]]* | ?:[[\\/]]*) + re_direlt='/[[^/]][[^/]]*/\.\./' + # Canonicalize the pathname of ld + ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'` + while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do + ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"` + done + test -z "$LD" && LD="$ac_prog" + ;; + "") + # If it fails, then pretend we aren't using GCC. + ac_prog=ld + ;; + *) + # If it is relative, then search for the first ld in PATH. + with_gnu_ld=unknown + ;; + esac +elif test "$with_gnu_ld" = yes; then + AC_MSG_CHECKING([for GNU ld]) +else + AC_MSG_CHECKING([for non-GNU ld]) +fi +AC_CACHE_VAL(lt_cv_path_LD, +[if test -z "$LD"; then + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then + lt_cv_path_LD="$ac_dir/$ac_prog" + # Check to see if the program is GNU ld. I'd rather use --version, + # but apparently some variants of GNU ld only accept -v. + # Break only if it was the GNU/non-GNU ld that we prefer. + case `"$lt_cv_path_LD" -v 2>&1 &1 /dev/null 2>&1; then + lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL' + lt_cv_file_magic_cmd='func_win32_libid' + else + # Keep this pattern in sync with the one in func_win32_libid. + lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' + lt_cv_file_magic_cmd='$OBJDUMP -f' + fi + ;; + +cegcc*) + # use the weaker test based on 'objdump'. See mingw*. + lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?' + lt_cv_file_magic_cmd='$OBJDUMP -f' + ;; + +darwin* | rhapsody*) + lt_cv_deplibs_check_method=pass_all + ;; + +freebsd* | dragonfly*) + if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then + case $host_cpu in + i*86 ) + # Not sure whether the presence of OpenBSD here was a mistake. + # Let's accept both of them until this is cleared up. + lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[[3-9]]86 (compact )?demand paged shared library' + lt_cv_file_magic_cmd=/usr/bin/file + lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*` + ;; + esac + else + lt_cv_deplibs_check_method=pass_all + fi + ;; + +haiku*) + lt_cv_deplibs_check_method=pass_all + ;; + +hpux10.20* | hpux11*) + lt_cv_file_magic_cmd=/usr/bin/file + case $host_cpu in + ia64*) + lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|ELF-[[0-9]][[0-9]]) shared object file - IA64' + lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so + ;; + hppa*64*) + [lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF[ -][0-9][0-9])(-bit)?( [LM]SB)? shared object( file)?[, -]* PA-RISC [0-9]\.[0-9]'] + lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl + ;; + *) + lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]]\.[[0-9]]) shared library' + lt_cv_file_magic_test_file=/usr/lib/libc.sl + ;; + esac + ;; + +interix[[3-9]]*) + # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here + lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|\.a)$' + ;; + +irix5* | irix6* | nonstopux*) + case $LD in + *-32|*"-32 ") libmagic=32-bit;; + *-n32|*"-n32 ") libmagic=N32;; + *-64|*"-64 ") libmagic=64-bit;; + *) libmagic=never-match;; + esac + lt_cv_deplibs_check_method=pass_all + ;; + +# This must be glibc/ELF. +linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + lt_cv_deplibs_check_method=pass_all + ;; + +netbsd* | netbsdelf*-gnu) + if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then + lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$' + else + lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|_pic\.a)$' + fi + ;; + +newos6*) + lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (executable|dynamic lib)' + lt_cv_file_magic_cmd=/usr/bin/file + lt_cv_file_magic_test_file=/usr/lib/libnls.so + ;; + +*nto* | *qnx*) + lt_cv_deplibs_check_method=pass_all + ;; + +openbsd*) + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|\.so|_pic\.a)$' + else + lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$' + fi + ;; + +osf3* | osf4* | osf5*) + lt_cv_deplibs_check_method=pass_all + ;; + +rdos*) + lt_cv_deplibs_check_method=pass_all + ;; + +solaris*) + lt_cv_deplibs_check_method=pass_all + ;; + +sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) + lt_cv_deplibs_check_method=pass_all + ;; + +sysv4 | sysv4.3*) + case $host_vendor in + motorola) + lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib) M[[0-9]][[0-9]]* Version [[0-9]]' + lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*` + ;; + ncr) + lt_cv_deplibs_check_method=pass_all + ;; + sequent) + lt_cv_file_magic_cmd='/bin/file' + lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )' + ;; + sni) + lt_cv_file_magic_cmd='/bin/file' + lt_cv_deplibs_check_method="file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB dynamic lib" + lt_cv_file_magic_test_file=/lib/libc.so + ;; + siemens) + lt_cv_deplibs_check_method=pass_all + ;; + pc) + lt_cv_deplibs_check_method=pass_all + ;; + esac + ;; + +tpf*) + lt_cv_deplibs_check_method=pass_all + ;; +esac +]) + +file_magic_glob= +want_nocaseglob=no +if test "$build" = "$host"; then + case $host_os in + mingw* | pw32*) + if ( shopt | grep nocaseglob ) >/dev/null 2>&1; then + want_nocaseglob=yes + else + file_magic_glob=`echo aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ | $SED -e "s/\(..\)/s\/[[\1]]\/[[\1]]\/g;/g"` + fi + ;; + esac +fi + +file_magic_cmd=$lt_cv_file_magic_cmd +deplibs_check_method=$lt_cv_deplibs_check_method +test -z "$deplibs_check_method" && deplibs_check_method=unknown + +_LT_DECL([], [deplibs_check_method], [1], + [Method to check whether dependent libraries are shared objects]) +_LT_DECL([], [file_magic_cmd], [1], + [Command to use when deplibs_check_method = "file_magic"]) +_LT_DECL([], [file_magic_glob], [1], + [How to find potential files when deplibs_check_method = "file_magic"]) +_LT_DECL([], [want_nocaseglob], [1], + [Find potential files using nocaseglob when deplibs_check_method = "file_magic"]) +])# _LT_CHECK_MAGIC_METHOD + + +# LT_PATH_NM +# ---------- +# find the pathname to a BSD- or MS-compatible name lister +AC_DEFUN([LT_PATH_NM], +[AC_REQUIRE([AC_PROG_CC])dnl +AC_CACHE_CHECK([for BSD- or MS-compatible name lister (nm)], lt_cv_path_NM, +[if test -n "$NM"; then + # Let the user override the test. + lt_cv_path_NM="$NM" +else + lt_nm_to_check="${ac_tool_prefix}nm" + if test -n "$ac_tool_prefix" && test "$build" = "$host"; then + lt_nm_to_check="$lt_nm_to_check nm" + fi + for lt_tmp_nm in $lt_nm_to_check; do + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + tmp_nm="$ac_dir/$lt_tmp_nm" + if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then + # Check to see if the nm accepts a BSD-compat flag. + # Adding the `sed 1q' prevents false positives on HP-UX, which says: + # nm: unknown option "B" ignored + # Tru64's nm complains that /dev/null is an invalid object file + case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in + */dev/null* | *'Invalid file or object type'*) + lt_cv_path_NM="$tmp_nm -B" + break + ;; + *) + case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in + */dev/null*) + lt_cv_path_NM="$tmp_nm -p" + break + ;; + *) + lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but + continue # so that we can try to find one that supports BSD flags + ;; + esac + ;; + esac + fi + done + IFS="$lt_save_ifs" + done + : ${lt_cv_path_NM=no} +fi]) +if test "$lt_cv_path_NM" != "no"; then + NM="$lt_cv_path_NM" +else + # Didn't find any BSD compatible name lister, look for dumpbin. + if test -n "$DUMPBIN"; then : + # Let the user override the test. + else + AC_CHECK_TOOLS(DUMPBIN, [dumpbin "link -dump"], :) + case `$DUMPBIN -symbols /dev/null 2>&1 | sed '1q'` in + *COFF*) + DUMPBIN="$DUMPBIN -symbols" + ;; + *) + DUMPBIN=: + ;; + esac + fi + AC_SUBST([DUMPBIN]) + if test "$DUMPBIN" != ":"; then + NM="$DUMPBIN" + fi +fi +test -z "$NM" && NM=nm +AC_SUBST([NM]) +_LT_DECL([], [NM], [1], [A BSD- or MS-compatible name lister])dnl + +AC_CACHE_CHECK([the name lister ($NM) interface], [lt_cv_nm_interface], + [lt_cv_nm_interface="BSD nm" + echo "int some_variable = 0;" > conftest.$ac_ext + (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&AS_MESSAGE_LOG_FD) + (eval "$ac_compile" 2>conftest.err) + cat conftest.err >&AS_MESSAGE_LOG_FD + (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&AS_MESSAGE_LOG_FD) + (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out) + cat conftest.err >&AS_MESSAGE_LOG_FD + (eval echo "\"\$as_me:$LINENO: output\"" >&AS_MESSAGE_LOG_FD) + cat conftest.out >&AS_MESSAGE_LOG_FD + if $GREP 'External.*some_variable' conftest.out > /dev/null; then + lt_cv_nm_interface="MS dumpbin" + fi + rm -f conftest*]) +])# LT_PATH_NM + +# Old names: +AU_ALIAS([AM_PROG_NM], [LT_PATH_NM]) +AU_ALIAS([AC_PROG_NM], [LT_PATH_NM]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AM_PROG_NM], []) +dnl AC_DEFUN([AC_PROG_NM], []) + +# _LT_CHECK_SHAREDLIB_FROM_LINKLIB +# -------------------------------- +# how to determine the name of the shared library +# associated with a specific link library. +# -- PORTME fill in with the dynamic library characteristics +m4_defun([_LT_CHECK_SHAREDLIB_FROM_LINKLIB], +[m4_require([_LT_DECL_EGREP]) +m4_require([_LT_DECL_OBJDUMP]) +m4_require([_LT_DECL_DLLTOOL]) +AC_CACHE_CHECK([how to associate runtime and link libraries], +lt_cv_sharedlib_from_linklib_cmd, +[lt_cv_sharedlib_from_linklib_cmd='unknown' + +case $host_os in +cygwin* | mingw* | pw32* | cegcc*) + # two different shell functions defined in ltmain.sh + # decide which to use based on capabilities of $DLLTOOL + case `$DLLTOOL --help 2>&1` in + *--identify-strict*) + lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib + ;; + *) + lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib_fallback + ;; + esac + ;; +*) + # fallback: assume linklib IS sharedlib + lt_cv_sharedlib_from_linklib_cmd="$ECHO" + ;; +esac +]) +sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd +test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO + +_LT_DECL([], [sharedlib_from_linklib_cmd], [1], + [Command to associate shared and link libraries]) +])# _LT_CHECK_SHAREDLIB_FROM_LINKLIB + + +# _LT_PATH_MANIFEST_TOOL +# ---------------------- +# locate the manifest tool +m4_defun([_LT_PATH_MANIFEST_TOOL], +[AC_CHECK_TOOL(MANIFEST_TOOL, mt, :) +test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt +AC_CACHE_CHECK([if $MANIFEST_TOOL is a manifest tool], [lt_cv_path_mainfest_tool], + [lt_cv_path_mainfest_tool=no + echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&AS_MESSAGE_LOG_FD + $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out + cat conftest.err >&AS_MESSAGE_LOG_FD + if $GREP 'Manifest Tool' conftest.out > /dev/null; then + lt_cv_path_mainfest_tool=yes + fi + rm -f conftest*]) +if test "x$lt_cv_path_mainfest_tool" != xyes; then + MANIFEST_TOOL=: +fi +_LT_DECL([], [MANIFEST_TOOL], [1], [Manifest tool])dnl +])# _LT_PATH_MANIFEST_TOOL + + +# LT_LIB_M +# -------- +# check for math library +AC_DEFUN([LT_LIB_M], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +LIBM= +case $host in +*-*-beos* | *-*-cegcc* | *-*-cygwin* | *-*-haiku* | *-*-pw32* | *-*-darwin*) + # These system don't have libm, or don't need it + ;; +*-ncr-sysv4.3*) + AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw") + AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm") + ;; +*) + AC_CHECK_LIB(m, cos, LIBM="-lm") + ;; +esac +AC_SUBST([LIBM]) +])# LT_LIB_M + +# Old name: +AU_ALIAS([AC_CHECK_LIBM], [LT_LIB_M]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_CHECK_LIBM], []) + + +# _LT_COMPILER_NO_RTTI([TAGNAME]) +# ------------------------------- +m4_defun([_LT_COMPILER_NO_RTTI], +[m4_require([_LT_TAG_COMPILER])dnl + +_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)= + +if test "$GCC" = yes; then + case $cc_basename in + nvcc*) + _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -Xcompiler -fno-builtin' ;; + *) + _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin' ;; + esac + + _LT_COMPILER_OPTION([if $compiler supports -fno-rtti -fno-exceptions], + lt_cv_prog_compiler_rtti_exceptions, + [-fno-rtti -fno-exceptions], [], + [_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)="$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1) -fno-rtti -fno-exceptions"]) +fi +_LT_TAGDECL([no_builtin_flag], [lt_prog_compiler_no_builtin_flag], [1], + [Compiler flag to turn off builtin functions]) +])# _LT_COMPILER_NO_RTTI + + +# _LT_CMD_GLOBAL_SYMBOLS +# ---------------------- +m4_defun([_LT_CMD_GLOBAL_SYMBOLS], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +AC_REQUIRE([AC_PROG_CC])dnl +AC_REQUIRE([AC_PROG_AWK])dnl +AC_REQUIRE([LT_PATH_NM])dnl +AC_REQUIRE([LT_PATH_LD])dnl +m4_require([_LT_DECL_SED])dnl +m4_require([_LT_DECL_EGREP])dnl +m4_require([_LT_TAG_COMPILER])dnl + +# Check for command to grab the raw symbol name followed by C symbol from nm. +AC_MSG_CHECKING([command to parse $NM output from $compiler object]) +AC_CACHE_VAL([lt_cv_sys_global_symbol_pipe], +[ +# These are sane defaults that work on at least a few old systems. +# [They come from Ultrix. What could be older than Ultrix?!! ;)] + +# Character class describing NM global symbol codes. +symcode='[[BCDEGRST]]' + +# Regexp to match symbols that can be accessed directly from C. +sympat='\([[_A-Za-z]][[_A-Za-z0-9]]*\)' + +# Define system-specific variables. +case $host_os in +aix*) + symcode='[[BCDT]]' + ;; +cygwin* | mingw* | pw32* | cegcc*) + symcode='[[ABCDGISTW]]' + ;; +hpux*) + if test "$host_cpu" = ia64; then + symcode='[[ABCDEGRST]]' + fi + ;; +irix* | nonstopux*) + symcode='[[BCDEGRST]]' + ;; +osf*) + symcode='[[BCDEGQRST]]' + ;; +solaris*) + symcode='[[BDRT]]' + ;; +sco3.2v5*) + symcode='[[DT]]' + ;; +sysv4.2uw2*) + symcode='[[DT]]' + ;; +sysv5* | sco5v6* | unixware* | OpenUNIX*) + symcode='[[ABDT]]' + ;; +sysv4) + symcode='[[DFNSTU]]' + ;; +esac + +# If we're using GNU nm, then use its standard symbol codes. +case `$NM -V 2>&1` in +*GNU* | *'with BFD'*) + symcode='[[ABCDGIRSTW]]' ;; +esac + +# Transform an extracted symbol line into a proper C declaration. +# Some systems (esp. on ia64) link data and code symbols differently, +# so use this general approach. +lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'" + +# Transform an extracted symbol line into symbol name and symbol address +lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\)[[ ]]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/ {\"\2\", (void *) \&\2},/p'" +lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \([[^ ]]*\)[[ ]]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \(lib[[^ ]]*\)$/ {\"\2\", (void *) \&\2},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/ {\"lib\2\", (void *) \&\2},/p'" + +# Handle CRLF in mingw tool chain +opt_cr= +case $build_os in +mingw*) + opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp + ;; +esac + +# Try without a prefix underscore, then with it. +for ac_symprfx in "" "_"; do + + # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol. + symxfrm="\\1 $ac_symprfx\\2 \\2" + + # Write the raw and C identifiers. + if test "$lt_cv_nm_interface" = "MS dumpbin"; then + # Fake it for dumpbin and say T for any non-static function + # and D for any global variable. + # Also find C++ and __fastcall symbols from MSVC++, + # which start with @ or ?. + lt_cv_sys_global_symbol_pipe="$AWK ['"\ +" {last_section=section; section=\$ 3};"\ +" /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\ +" /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\ +" \$ 0!~/External *\|/{next};"\ +" / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\ +" {if(hide[section]) next};"\ +" {f=0}; \$ 0~/\(\).*\|/{f=1}; {printf f ? \"T \" : \"D \"};"\ +" {split(\$ 0, a, /\||\r/); split(a[2], s)};"\ +" s[1]~/^[@?]/{print s[1], s[1]; next};"\ +" s[1]~prfx {split(s[1],t,\"@\"); print t[1], substr(t[1],length(prfx))}"\ +" ' prfx=^$ac_symprfx]" + else + lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[ ]]\($symcode$symcode*\)[[ ]][[ ]]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'" + fi + lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | sed '/ __gnu_lto/d'" + + # Check to see that the pipe works correctly. + pipe_works=no + + rm -f conftest* + cat > conftest.$ac_ext <<_LT_EOF +#ifdef __cplusplus +extern "C" { +#endif +char nm_test_var; +void nm_test_func(void); +void nm_test_func(void){} +#ifdef __cplusplus +} +#endif +int main(){nm_test_var='a';nm_test_func();return(0);} +_LT_EOF + + if AC_TRY_EVAL(ac_compile); then + # Now try to grab the symbols. + nlist=conftest.nm + if AC_TRY_EVAL(NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist) && test -s "$nlist"; then + # Try sorting and uniquifying the output. + if sort "$nlist" | uniq > "$nlist"T; then + mv -f "$nlist"T "$nlist" + else + rm -f "$nlist"T + fi + + # Make sure that we snagged all the symbols we need. + if $GREP ' nm_test_var$' "$nlist" >/dev/null; then + if $GREP ' nm_test_func$' "$nlist" >/dev/null; then + cat <<_LT_EOF > conftest.$ac_ext +/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */ +#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE) +/* DATA imports from DLLs on WIN32 con't be const, because runtime + relocations are performed -- see ld's documentation on pseudo-relocs. */ +# define LT@&t@_DLSYM_CONST +#elif defined(__osf__) +/* This system does not cope well with relocations in const data. */ +# define LT@&t@_DLSYM_CONST +#else +# define LT@&t@_DLSYM_CONST const +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +_LT_EOF + # Now generate the symbol file. + eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext' + + cat <<_LT_EOF >> conftest.$ac_ext + +/* The mapping between symbol names and symbols. */ +LT@&t@_DLSYM_CONST struct { + const char *name; + void *address; +} +lt__PROGRAM__LTX_preloaded_symbols[[]] = +{ + { "@PROGRAM@", (void *) 0 }, +_LT_EOF + $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/ {\"\2\", (void *) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext + cat <<\_LT_EOF >> conftest.$ac_ext + {0, (void *) 0} +}; + +/* This works around a problem in FreeBSD linker */ +#ifdef FREEBSD_WORKAROUND +static const void *lt_preloaded_setup() { + return lt__PROGRAM__LTX_preloaded_symbols; +} +#endif + +#ifdef __cplusplus +} +#endif +_LT_EOF + # Now try linking the two files. + mv conftest.$ac_objext conftstm.$ac_objext + lt_globsym_save_LIBS=$LIBS + lt_globsym_save_CFLAGS=$CFLAGS + LIBS="conftstm.$ac_objext" + CFLAGS="$CFLAGS$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)" + if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext}; then + pipe_works=yes + fi + LIBS=$lt_globsym_save_LIBS + CFLAGS=$lt_globsym_save_CFLAGS + else + echo "cannot find nm_test_func in $nlist" >&AS_MESSAGE_LOG_FD + fi + else + echo "cannot find nm_test_var in $nlist" >&AS_MESSAGE_LOG_FD + fi + else + echo "cannot run $lt_cv_sys_global_symbol_pipe" >&AS_MESSAGE_LOG_FD + fi + else + echo "$progname: failed program was:" >&AS_MESSAGE_LOG_FD + cat conftest.$ac_ext >&5 + fi + rm -rf conftest* conftst* + + # Do not use the global_symbol_pipe unless it works. + if test "$pipe_works" = yes; then + break + else + lt_cv_sys_global_symbol_pipe= + fi +done +]) +if test -z "$lt_cv_sys_global_symbol_pipe"; then + lt_cv_sys_global_symbol_to_cdecl= +fi +if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then + AC_MSG_RESULT(failed) +else + AC_MSG_RESULT(ok) +fi + +# Response file support. +if test "$lt_cv_nm_interface" = "MS dumpbin"; then + nm_file_list_spec='@' +elif $NM --help 2>/dev/null | grep '[[@]]FILE' >/dev/null; then + nm_file_list_spec='@' +fi + +_LT_DECL([global_symbol_pipe], [lt_cv_sys_global_symbol_pipe], [1], + [Take the output of nm and produce a listing of raw symbols and C names]) +_LT_DECL([global_symbol_to_cdecl], [lt_cv_sys_global_symbol_to_cdecl], [1], + [Transform the output of nm in a proper C declaration]) +_LT_DECL([global_symbol_to_c_name_address], + [lt_cv_sys_global_symbol_to_c_name_address], [1], + [Transform the output of nm in a C name address pair]) +_LT_DECL([global_symbol_to_c_name_address_lib_prefix], + [lt_cv_sys_global_symbol_to_c_name_address_lib_prefix], [1], + [Transform the output of nm in a C name address pair when lib prefix is needed]) +_LT_DECL([], [nm_file_list_spec], [1], + [Specify filename containing input files for $NM]) +]) # _LT_CMD_GLOBAL_SYMBOLS + + +# _LT_COMPILER_PIC([TAGNAME]) +# --------------------------- +m4_defun([_LT_COMPILER_PIC], +[m4_require([_LT_TAG_COMPILER])dnl +_LT_TAGVAR(lt_prog_compiler_wl, $1)= +_LT_TAGVAR(lt_prog_compiler_pic, $1)= +_LT_TAGVAR(lt_prog_compiler_static, $1)= + +m4_if([$1], [CXX], [ + # C++ specific cases for pic, static, wl, etc. + if test "$GXX" = yes; then + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + m68k) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the `-m68020' flag to GCC prevents building anything better, + # like `-m68040'. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4' + ;; + esac + ;; + + beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + mingw* | cygwin* | os2* | pw32* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + # Although the cygwin gcc ignores -fPIC, still need this for old-style + # (--disable-auto-import) libraries + m4_if([$1], [GCJ], [], + [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) + ;; + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common' + ;; + *djgpp*) + # DJGPP does not support shared libraries at all + _LT_TAGVAR(lt_prog_compiler_pic, $1)= + ;; + haiku*) + # PIC is the default for Haiku. + # The "-static" flag exists, but is broken. + _LT_TAGVAR(lt_prog_compiler_static, $1)= + ;; + interix[[3-9]]*) + # Interix 3.x gcc -fpic/-fPIC options generate broken code. + # Instead, we relocate shared libraries at runtime. + ;; + sysv4*MP*) + if test -d /usr/nec; then + _LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic + fi + ;; + hpux*) + # PIC is the default for 64-bit PA HP-UX, but not for 32-bit + # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag + # sets the default TLS model and affects inlining. + case $host_cpu in + hppa*64*) + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + esac + ;; + *qnx* | *nto*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + esac + else + case $host_os in + aix[[4-9]]*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + else + _LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp' + fi + ;; + chorus*) + case $cc_basename in + cxch68*) + # Green Hills C++ Compiler + # _LT_TAGVAR(lt_prog_compiler_static, $1)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a" + ;; + esac + ;; + mingw* | cygwin* | os2* | pw32* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + m4_if([$1], [GCJ], [], + [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) + ;; + dgux*) + case $cc_basename in + ec++*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + ;; + ghcx*) + # Green Hills C++ Compiler + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + ;; + *) + ;; + esac + ;; + freebsd* | dragonfly*) + # FreeBSD uses GNU C++ + ;; + hpux9* | hpux10* | hpux11*) + case $cc_basename in + CC*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive' + if test "$host_cpu" != ia64; then + _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z' + fi + ;; + aCC*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive' + case $host_cpu in + hppa*64*|ia64*) + # +Z the default + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z' + ;; + esac + ;; + *) + ;; + esac + ;; + interix*) + # This is c89, which is MS Visual C++ (no shared libs) + # Anyone wants to do a port? + ;; + irix5* | irix6* | nonstopux*) + case $cc_basename in + CC*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + # CC pic flag -KPIC is the default. + ;; + *) + ;; + esac + ;; + linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + case $cc_basename in + KCC*) + # KAI C++ Compiler + _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + ecpc* ) + # old Intel C++ for x86_64 which still supported -KPIC. + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; + icpc* ) + # Intel C++, used to be incompatible with GCC. + # ICC 10 doesn't accept -KPIC any more. + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; + pgCC* | pgcpp*) + # Portland Group C++ compiler + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + cxx*) + # Compaq C++ + # Make sure the PIC flag is empty. It appears that all Alpha + # Linux and Compaq Tru64 Unix objects are PIC. + _LT_TAGVAR(lt_prog_compiler_pic, $1)= + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + xlc* | xlC* | bgxl[[cC]]* | mpixl[[cC]]*) + # IBM XL 8.0, 9.0 on PPC and BlueGene + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink' + ;; + *) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) + # Sun C++ 5.9 + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' + ;; + esac + ;; + esac + ;; + lynxos*) + ;; + m88k*) + ;; + mvs*) + case $cc_basename in + cxx*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-W c,exportall' + ;; + *) + ;; + esac + ;; + netbsd* | netbsdelf*-gnu) + ;; + *qnx* | *nto*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' + ;; + osf3* | osf4* | osf5*) + case $cc_basename in + KCC*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,' + ;; + RCC*) + # Rational C++ 2.4.1 + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + ;; + cxx*) + # Digital/Compaq C++ + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # Make sure the PIC flag is empty. It appears that all Alpha + # Linux and Compaq Tru64 Unix objects are PIC. + _LT_TAGVAR(lt_prog_compiler_pic, $1)= + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + *) + ;; + esac + ;; + psos*) + ;; + solaris*) + case $cc_basename in + CC* | sunCC*) + # Sun C++ 4.2, 5.x and Centerline C++ + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' + ;; + gcx*) + # Green Hills C++ Compiler + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' + ;; + *) + ;; + esac + ;; + sunos4*) + case $cc_basename in + CC*) + # Sun C++ 4.x + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + lcc*) + # Lucid + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + ;; + *) + ;; + esac + ;; + sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) + case $cc_basename in + CC*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + esac + ;; + tandem*) + case $cc_basename in + NCC*) + # NonStop-UX NCC 3.20 + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + ;; + *) + ;; + esac + ;; + vxworks*) + ;; + *) + _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no + ;; + esac + fi +], +[ + if test "$GCC" = yes; then + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + m68k) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the `-m68020' flag to GCC prevents building anything better, + # like `-m68040'. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4' + ;; + esac + ;; + + beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + + mingw* | cygwin* | pw32* | os2* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + # Although the cygwin gcc ignores -fPIC, still need this for old-style + # (--disable-auto-import) libraries + m4_if([$1], [GCJ], [], + [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) + ;; + + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common' + ;; + + haiku*) + # PIC is the default for Haiku. + # The "-static" flag exists, but is broken. + _LT_TAGVAR(lt_prog_compiler_static, $1)= + ;; + + hpux*) + # PIC is the default for 64-bit PA HP-UX, but not for 32-bit + # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag + # sets the default TLS model and affects inlining. + case $host_cpu in + hppa*64*) + # +Z the default + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + esac + ;; + + interix[[3-9]]*) + # Interix 3.x gcc -fpic/-fPIC options generate broken code. + # Instead, we relocate shared libraries at runtime. + ;; + + msdosdjgpp*) + # Just because we use GCC doesn't mean we suddenly get shared libraries + # on systems that don't support them. + _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no + enable_shared=no + ;; + + *nto* | *qnx*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' + ;; + + sysv4*MP*) + if test -d /usr/nec; then + _LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic + fi + ;; + + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + esac + + case $cc_basename in + nvcc*) # Cuda Compiler Driver 2.2 + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Xlinker ' + if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then + _LT_TAGVAR(lt_prog_compiler_pic, $1)="-Xcompiler $_LT_TAGVAR(lt_prog_compiler_pic, $1)" + fi + ;; + esac + else + # PORTME Check for flag to pass linker flags through the system compiler. + case $host_os in + aix*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + else + _LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp' + fi + ;; + + mingw* | cygwin* | pw32* | os2* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + m4_if([$1], [GCJ], [], + [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) + ;; + + hpux9* | hpux10* | hpux11*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case $host_cpu in + hppa*64*|ia64*) + # +Z the default + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z' + ;; + esac + # Is there a better lt_prog_compiler_static that works with the bundled CC? + _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive' + ;; + + irix5* | irix6* | nonstopux*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # PIC (with -KPIC) is the default. + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + + linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + case $cc_basename in + # old Intel for x86_64 which still supported -KPIC. + ecc*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; + # icc used to be incompatible with GCC. + # ICC 10 doesn't accept -KPIC any more. + icc* | ifort*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; + # Lahey Fortran 8.1. + lf95*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='--shared' + _LT_TAGVAR(lt_prog_compiler_static, $1)='--static' + ;; + nagfor*) + # NAG Fortran compiler + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,-Wl,,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*) + # Portland Group compilers (*not* the Pentium gcc compiler, + # which looks to be a dead project) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + ccc*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # All Alpha code is PIC. + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + xl* | bgxl* | bgf* | mpixl*) + # IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink' + ;; + *) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ Ceres\ Fortran* | *Sun*Fortran*\ [[1-7]].* | *Sun*Fortran*\ 8.[[0-3]]*) + # Sun Fortran 8.3 passes all unrecognized flags to the linker + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + _LT_TAGVAR(lt_prog_compiler_wl, $1)='' + ;; + *Sun\ F* | *Sun*Fortran*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' + ;; + *Sun\ C*) + # Sun C 5.9 + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + ;; + *Intel*\ [[CF]]*Compiler*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; + *Portland\ Group*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + esac + ;; + esac + ;; + + newsos6) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + *nto* | *qnx*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' + ;; + + osf3* | osf4* | osf5*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # All OSF/1 code is PIC. + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + + rdos*) + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + + solaris*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + case $cc_basename in + f77* | f90* | f95* | sunf77* | sunf90* | sunf95*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ';; + *) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,';; + esac + ;; + + sunos4*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + sysv4 | sysv4.2uw2* | sysv4.3*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + sysv4*MP*) + if test -d /usr/nec ;then + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-Kconform_pic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + fi + ;; + + sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + unicos*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no + ;; + + uts4*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + *) + _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no + ;; + esac + fi +]) +case $host_os in + # For platforms which do not support PIC, -DPIC is meaningless: + *djgpp*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)= + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)="$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])" + ;; +esac + +AC_CACHE_CHECK([for $compiler option to produce PIC], + [_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)], + [_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_prog_compiler_pic, $1)]) +_LT_TAGVAR(lt_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_cv_prog_compiler_pic, $1) + +# +# Check to make sure the PIC flag actually works. +# +if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then + _LT_COMPILER_OPTION([if $compiler PIC flag $_LT_TAGVAR(lt_prog_compiler_pic, $1) works], + [_LT_TAGVAR(lt_cv_prog_compiler_pic_works, $1)], + [$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])], [], + [case $_LT_TAGVAR(lt_prog_compiler_pic, $1) in + "" | " "*) ;; + *) _LT_TAGVAR(lt_prog_compiler_pic, $1)=" $_LT_TAGVAR(lt_prog_compiler_pic, $1)" ;; + esac], + [_LT_TAGVAR(lt_prog_compiler_pic, $1)= + _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no]) +fi +_LT_TAGDECL([pic_flag], [lt_prog_compiler_pic], [1], + [Additional compiler flags for building library objects]) + +_LT_TAGDECL([wl], [lt_prog_compiler_wl], [1], + [How to pass a linker flag through the compiler]) +# +# Check to make sure the static flag actually works. +# +wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1) eval lt_tmp_static_flag=\"$_LT_TAGVAR(lt_prog_compiler_static, $1)\" +_LT_LINKER_OPTION([if $compiler static flag $lt_tmp_static_flag works], + _LT_TAGVAR(lt_cv_prog_compiler_static_works, $1), + $lt_tmp_static_flag, + [], + [_LT_TAGVAR(lt_prog_compiler_static, $1)=]) +_LT_TAGDECL([link_static_flag], [lt_prog_compiler_static], [1], + [Compiler flag to prevent dynamic linking]) +])# _LT_COMPILER_PIC + + +# _LT_LINKER_SHLIBS([TAGNAME]) +# ---------------------------- +# See if the linker supports building shared libraries. +m4_defun([_LT_LINKER_SHLIBS], +[AC_REQUIRE([LT_PATH_LD])dnl +AC_REQUIRE([LT_PATH_NM])dnl +m4_require([_LT_PATH_MANIFEST_TOOL])dnl +m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_DECL_EGREP])dnl +m4_require([_LT_DECL_SED])dnl +m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl +m4_require([_LT_TAG_COMPILER])dnl +AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries]) +m4_if([$1], [CXX], [ + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'] + case $host_os in + aix[[4-9]]*) + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to AIX nm, but means don't demangle with GNU nm + # Also, AIX nm treats weak defined symbols like other global defined + # symbols, whereas GNU nm marks them as "W". + if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then + _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + else + _LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + fi + ;; + pw32*) + _LT_TAGVAR(export_symbols_cmds, $1)="$ltdll_cmds" + ;; + cygwin* | mingw* | cegcc*) + case $cc_basename in + cl*) + _LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*' + ;; + *) + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols' + _LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'] + ;; + esac + ;; + linux* | k*bsd*-gnu | gnu*) + _LT_TAGVAR(link_all_deplibs, $1)=no + ;; + *) + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + ;; + esac +], [ + runpath_var= + _LT_TAGVAR(allow_undefined_flag, $1)= + _LT_TAGVAR(always_export_symbols, $1)=no + _LT_TAGVAR(archive_cmds, $1)= + _LT_TAGVAR(archive_expsym_cmds, $1)= + _LT_TAGVAR(compiler_needs_object, $1)=no + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no + _LT_TAGVAR(export_dynamic_flag_spec, $1)= + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + _LT_TAGVAR(hardcode_automatic, $1)=no + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_direct_absolute, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= + _LT_TAGVAR(hardcode_libdir_separator, $1)= + _LT_TAGVAR(hardcode_minus_L, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported + _LT_TAGVAR(inherit_rpath, $1)=no + _LT_TAGVAR(link_all_deplibs, $1)=unknown + _LT_TAGVAR(module_cmds, $1)= + _LT_TAGVAR(module_expsym_cmds, $1)= + _LT_TAGVAR(old_archive_from_new_cmds, $1)= + _LT_TAGVAR(old_archive_from_expsyms_cmds, $1)= + _LT_TAGVAR(thread_safe_flag_spec, $1)= + _LT_TAGVAR(whole_archive_flag_spec, $1)= + # include_expsyms should be a list of space-separated symbols to be *always* + # included in the symbol list + _LT_TAGVAR(include_expsyms, $1)= + # exclude_expsyms can be an extended regexp of symbols to exclude + # it will be wrapped by ` (' and `)$', so one must not match beginning or + # end of line. Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc', + # as well as any symbol that contains `d'. + _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'] + # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out + # platforms (ab)use it in PIC code, but their linkers get confused if + # the symbol is explicitly referenced. Since portable code cannot + # rely on this symbol name, it's probably fine to never include it in + # preloaded symbol tables. + # Exclude shared library initialization/finalization symbols. +dnl Note also adjust exclude_expsyms for C++ above. + extract_expsyms_cmds= + + case $host_os in + cygwin* | mingw* | pw32* | cegcc*) + # FIXME: the MSVC++ port hasn't been tested in a loooong time + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + if test "$GCC" != yes; then + with_gnu_ld=no + fi + ;; + interix*) + # we just hope/assume this is gcc and not c89 (= MSVC++) + with_gnu_ld=yes + ;; + openbsd*) + with_gnu_ld=no + ;; + linux* | k*bsd*-gnu | gnu*) + _LT_TAGVAR(link_all_deplibs, $1)=no + ;; + esac + + _LT_TAGVAR(ld_shlibs, $1)=yes + + # On some targets, GNU ld is compatible enough with the native linker + # that we're better off using the native interface for both. + lt_use_gnu_ld_interface=no + if test "$with_gnu_ld" = yes; then + case $host_os in + aix*) + # The AIX port of GNU ld has always aspired to compatibility + # with the native linker. However, as the warning in the GNU ld + # block says, versions before 2.19.5* couldn't really create working + # shared libraries, regardless of the interface used. + case `$LD -v 2>&1` in + *\ \(GNU\ Binutils\)\ 2.19.5*) ;; + *\ \(GNU\ Binutils\)\ 2.[[2-9]]*) ;; + *\ \(GNU\ Binutils\)\ [[3-9]]*) ;; + *) + lt_use_gnu_ld_interface=yes + ;; + esac + ;; + *) + lt_use_gnu_ld_interface=yes + ;; + esac + fi + + if test "$lt_use_gnu_ld_interface" = yes; then + # If archive_cmds runs LD, not CC, wlarc should be empty + wlarc='${wl}' + + # Set some defaults for GNU ld with shared library support. These + # are reset later if shared libraries are not supported. Putting them + # here allows them to be overridden if necessary. + runpath_var=LD_RUN_PATH + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + # ancient GNU ld didn't support --whole-archive et. al. + if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then + _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + else + _LT_TAGVAR(whole_archive_flag_spec, $1)= + fi + supports_anon_versioning=no + case `$LD -v 2>&1` in + *GNU\ gold*) supports_anon_versioning=yes ;; + *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11 + *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ... + *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ... + *\ 2.11.*) ;; # other 2.11 versions + *) supports_anon_versioning=yes ;; + esac + + # See if GNU ld supports shared libraries. + case $host_os in + aix[[3-9]]*) + # On AIX/PPC, the GNU linker is very broken + if test "$host_cpu" != ia64; then + _LT_TAGVAR(ld_shlibs, $1)=no + cat <<_LT_EOF 1>&2 + +*** Warning: the GNU linker, at least up to release 2.19, is reported +*** to be unable to reliably create shared libraries on AIX. +*** Therefore, libtool is disabling shared libraries support. If you +*** really care for shared libraries, you may want to install binutils +*** 2.20 or above, or modify your PATH so that a non-GNU linker is found. +*** You will then need to restart the configuration process. + +_LT_EOF + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='' + ;; + m68k) + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_minus_L, $1)=yes + ;; + esac + ;; + + beos*) + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + # Joseph Beckenbach says some releases of gcc + # support --undefined. This deserves some investigation. FIXME + _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + cygwin* | mingw* | pw32* | cegcc*) + # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless, + # as there is no search path for DLLs. + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-all-symbols' + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_TAGVAR(always_export_symbols, $1)=no + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols' + _LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'] + + if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + # If the export-symbols file already is a .def file (1st line + # is EXPORTS), use it as is; otherwise, prepend... + _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + haiku*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(link_all_deplibs, $1)=yes + ;; + + interix[[3-9]]*) + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc. + # Instead, shared libraries are loaded at an image base (0x10000000 by + # default) and relocated if they conflict, which is a slow very memory + # consuming and fragmenting process. To avoid this, we pick a random, + # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link + # time. Moving up from 0x10000000 also allows more sbrk(2) space. + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + ;; + + gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu) + tmp_diet=no + if test "$host_os" = linux-dietlibc; then + case $cc_basename in + diet\ *) tmp_diet=yes;; # linux-dietlibc with static linking (!diet-dyn) + esac + fi + if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \ + && test "$tmp_diet" = no + then + tmp_addflag=' $pic_flag' + tmp_sharedflag='-shared' + case $cc_basename,$host_cpu in + pgcc*) # Portland Group C compiler + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + tmp_addflag=' $pic_flag' + ;; + pgf77* | pgf90* | pgf95* | pgfortran*) + # Portland Group f77 and f90 compilers + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + tmp_addflag=' $pic_flag -Mnomain' ;; + ecc*,ia64* | icc*,ia64*) # Intel C compiler on ia64 + tmp_addflag=' -i_dynamic' ;; + efc*,ia64* | ifort*,ia64*) # Intel Fortran compiler on ia64 + tmp_addflag=' -i_dynamic -nofor_main' ;; + ifc* | ifort*) # Intel Fortran compiler + tmp_addflag=' -nofor_main' ;; + lf95*) # Lahey Fortran 8.1 + _LT_TAGVAR(whole_archive_flag_spec, $1)= + tmp_sharedflag='--shared' ;; + xl[[cC]]* | bgxl[[cC]]* | mpixl[[cC]]*) # IBM XL C 8.0 on PPC (deal with xlf below) + tmp_sharedflag='-qmkshrobj' + tmp_addflag= ;; + nvcc*) # Cuda Compiler Driver 2.2 + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + _LT_TAGVAR(compiler_needs_object, $1)=yes + ;; + esac + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) # Sun C 5.9 + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + _LT_TAGVAR(compiler_needs_object, $1)=yes + tmp_sharedflag='-G' ;; + *Sun\ F*) # Sun Fortran 8.3 + tmp_sharedflag='-G' ;; + esac + _LT_TAGVAR(archive_cmds, $1)='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + + if test "x$supports_anon_versioning" = xyes; then + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~ + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' + fi + + case $cc_basename in + xlf* | bgf* | bgxlf* | mpixlf*) + # IBM XL Fortran 10.1 on PPC cannot create shared libs itself + _LT_TAGVAR(whole_archive_flag_spec, $1)='--whole-archive$convenience --no-whole-archive' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib' + if test "x$supports_anon_versioning" = xyes; then + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~ + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib' + fi + ;; + esac + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + netbsd* | netbsdelf*-gnu) + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib' + wlarc= + else + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + fi + ;; + + solaris*) + if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then + _LT_TAGVAR(ld_shlibs, $1)=no + cat <<_LT_EOF 1>&2 + +*** Warning: The releases 2.8.* of the GNU linker cannot reliably +*** create shared libraries on Solaris systems. Therefore, libtool +*** is disabling shared libraries support. We urge you to upgrade GNU +*** binutils to release 2.9.1 or newer. Another option is to modify +*** your PATH or compiler configuration so that the native linker is +*** used, and then restart. + +_LT_EOF + elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*) + case `$LD -v 2>&1` in + *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.1[[0-5]].*) + _LT_TAGVAR(ld_shlibs, $1)=no + cat <<_LT_EOF 1>&2 + +*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not +*** reliably create shared libraries on SCO systems. Therefore, libtool +*** is disabling shared libraries support. We urge you to upgrade GNU +*** binutils to release 2.16.91.0.3 or newer. Another option is to modify +*** your PATH or compiler configuration so that the native linker is +*** used, and then restart. + +_LT_EOF + ;; + *) + # For security reasons, it is highly recommended that you always + # use absolute paths for naming shared libraries, and exclude the + # DT_RUNPATH tag from executables and libraries. But doing so + # requires that you compile everything twice, which is a pain. + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + ;; + + sunos4*) + _LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags' + wlarc= + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + *) + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + + if test "$_LT_TAGVAR(ld_shlibs, $1)" = no; then + runpath_var= + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= + _LT_TAGVAR(export_dynamic_flag_spec, $1)= + _LT_TAGVAR(whole_archive_flag_spec, $1)= + fi + else + # PORTME fill in a description of your system's linker (not GNU ld) + case $host_os in + aix3*) + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_TAGVAR(always_export_symbols, $1)=yes + _LT_TAGVAR(archive_expsym_cmds, $1)='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname' + # Note: this linker hardcodes the directories in LIBPATH if there + # are no directories specified by -L. + _LT_TAGVAR(hardcode_minus_L, $1)=yes + if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then + # Neither direct hardcoding nor static linking is supported with a + # broken collect2. + _LT_TAGVAR(hardcode_direct, $1)=unsupported + fi + ;; + + aix[[4-9]]*) + if test "$host_cpu" = ia64; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag="" + else + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to AIX nm, but means don't demangle with GNU nm + # Also, AIX nm treats weak defined symbols like other global + # defined symbols, whereas GNU nm marks them as "W". + if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then + _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + else + _LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + fi + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # need to do runtime linking. + case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*) + for ld_flag in $LDFLAGS; do + if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then + aix_use_runtimelinking=yes + break + fi + done + ;; + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + _LT_TAGVAR(archive_cmds, $1)='' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(hardcode_libdir_separator, $1)=':' + _LT_TAGVAR(link_all_deplibs, $1)=yes + _LT_TAGVAR(file_list_spec, $1)='${wl}-f,' + + if test "$GCC" = yes; then + case $host_os in aix4.[[012]]|aix4.[[012]].*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`${CC} -print-prog-name=collect2` + if test -f "$collect2name" && + strings "$collect2name" | $GREP resolve_lib_name >/dev/null + then + # We have reworked collect2 + : + else + # We have old collect2 + _LT_TAGVAR(hardcode_direct, $1)=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)= + fi + ;; + esac + shared_flag='-shared' + if test "$aix_use_runtimelinking" = yes; then + shared_flag="$shared_flag "'${wl}-G' + fi + _LT_TAGVAR(link_all_deplibs, $1)=no + else + # not using gcc + if test "$host_cpu" = ia64; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test "$aix_use_runtimelinking" = yes; then + shared_flag='${wl}-G' + else + shared_flag='${wl}-bM:SRE' + fi + fi + fi + + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-bexpall' + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to export. + _LT_TAGVAR(always_export_symbols, $1)=yes + if test "$aix_use_runtimelinking" = yes; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + _LT_TAGVAR(allow_undefined_flag, $1)='-berok' + # Determine the default libpath from the value encoded in an + # empty executable. + _LT_SYS_MODULE_PATH_AIX([$1]) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag" + else + if test "$host_cpu" = ia64; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib' + _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs" + _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an + # empty executable. + _LT_SYS_MODULE_PATH_AIX([$1]) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok' + _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok' + if test "$with_gnu_ld" = yes; then + # We only use this code for GNU lds that support --whole-archive. + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + else + # Exported symbols can be pulled into shared objects from archives + _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience' + fi + _LT_TAGVAR(archive_cmds_need_lc, $1)=yes + # This is similar to how AIX traditionally builds its shared libraries. + _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + fi + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='' + ;; + m68k) + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_minus_L, $1)=yes + ;; + esac + ;; + + bsdi[[45]]*) + _LT_TAGVAR(export_dynamic_flag_spec, $1)=-rdynamic + ;; + + cygwin* | mingw* | pw32* | cegcc*) + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + # hardcode_libdir_flag_spec is actually meaningless, as there is + # no search path for DLLs. + case $cc_basename in + cl*) + # Native MSVC + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' ' + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_TAGVAR(always_export_symbols, $1)=yes + _LT_TAGVAR(file_list_spec, $1)='@' + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames=' + _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + sed -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp; + else + sed -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp; + fi~ + $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ + linknames=' + # The linker will not automatically build a static lib if we build a DLL. + # _LT_TAGVAR(old_archive_from_new_cmds, $1)='true' + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + _LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*' + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1,DATA/'\'' | $SED -e '\''/^[[AITW]][[ ]]/s/.*[[ ]]//'\'' | sort | uniq > $export_symbols' + # Don't use ranlib + _LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib' + _LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~ + lt_tool_outputfile="@TOOL_OUTPUT@"~ + case $lt_outputfile in + *.exe|*.EXE) ;; + *) + lt_outputfile="$lt_outputfile.exe" + lt_tool_outputfile="$lt_tool_outputfile.exe" + ;; + esac~ + if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then + $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; + $RM "$lt_outputfile.manifest"; + fi' + ;; + *) + # Assume MSVC wrapper + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' ' + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + _LT_TAGVAR(archive_cmds, $1)='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames=' + # The linker will automatically build a .lib file if we build a DLL. + _LT_TAGVAR(old_archive_from_new_cmds, $1)='true' + # FIXME: Should let the user specify the lib program. + _LT_TAGVAR(old_archive_cmds, $1)='lib -OUT:$oldlib$oldobjs$old_deplibs' + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + ;; + esac + ;; + + darwin* | rhapsody*) + _LT_DARWIN_LINKER_FEATURES($1) + ;; + + dgux*) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor + # support. Future versions do this automatically, but an explicit c++rt0.o + # does not break anything, and helps significantly (at the cost of a little + # extra space). + freebsd2.2*) + _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + # Unfortunately, older versions of FreeBSD 2 do not have this feature. + freebsd2.*) + _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + # FreeBSD 3 and greater uses gcc -shared to do shared libraries. + freebsd* | dragonfly*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + hpux9*) + if test "$GCC" = yes; then + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + else + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + fi + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_TAGVAR(hardcode_direct, $1)=yes + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + ;; + + hpux10*) + if test "$GCC" = yes && test "$with_gnu_ld" = no; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + else + _LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' + fi + if test "$with_gnu_ld" = no; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + _LT_TAGVAR(hardcode_minus_L, $1)=yes + fi + ;; + + hpux11*) + if test "$GCC" = yes && test "$with_gnu_ld" = no; then + case $host_cpu in + hppa*64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + ia64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + else + case $host_cpu in + hppa*64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + ia64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + m4_if($1, [], [ + # Older versions of the 11.00 compiler do not understand -b yet + # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does) + _LT_LINKER_OPTION([if $CC understands -b], + _LT_TAGVAR(lt_cv_prog_compiler__b, $1), [-b], + [_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'], + [_LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'])], + [_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags']) + ;; + esac + fi + if test "$with_gnu_ld" = no; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + case $host_cpu in + hppa*64*|ia64*) + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + *) + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + _LT_TAGVAR(hardcode_minus_L, $1)=yes + ;; + esac + fi + ;; + + irix5* | irix6* | nonstopux*) + if test "$GCC" = yes; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + # Try to use the -exported_symbol ld option, if it does not + # work, assume that -exports_file does not work either and + # implicitly export all symbols. + # This should be the same for all languages, so no per-tag cache variable. + AC_CACHE_CHECK([whether the $host_os linker accepts -exported_symbol], + [lt_cv_irix_exported_symbol], + [save_LDFLAGS="$LDFLAGS" + LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null" + AC_LINK_IFELSE( + [AC_LANG_SOURCE( + [AC_LANG_CASE([C], [[int foo (void) { return 0; }]], + [C++], [[int foo (void) { return 0; }]], + [Fortran 77], [[ + subroutine foo + end]], + [Fortran], [[ + subroutine foo + end]])])], + [lt_cv_irix_exported_symbol=yes], + [lt_cv_irix_exported_symbol=no]) + LDFLAGS="$save_LDFLAGS"]) + if test "$lt_cv_irix_exported_symbol" = yes; then + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib' + fi + else + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib' + fi + _LT_TAGVAR(archive_cmds_need_lc, $1)='no' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_TAGVAR(inherit_rpath, $1)=yes + _LT_TAGVAR(link_all_deplibs, $1)=yes + ;; + + netbsd* | netbsdelf*-gnu) + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out + else + _LT_TAGVAR(archive_cmds, $1)='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF + fi + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + newsos6) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + *nto* | *qnx*) + ;; + + openbsd*) + if test -f /usr/libexec/ld.so; then + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + else + case $host_os in + openbsd[[01]].* | openbsd2.[[0-7]] | openbsd2.[[0-7]].*) + _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + ;; + esac + fi + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + os2*) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~echo DATA >> $output_objdir/$libname.def~echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def' + _LT_TAGVAR(old_archive_from_new_cmds, $1)='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def' + ;; + + osf3*) + if test "$GCC" = yes; then + _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + fi + _LT_TAGVAR(archive_cmds_need_lc, $1)='no' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + ;; + + osf4* | osf5*) # as osf3* with the addition of -msym flag + if test "$GCC" = yes; then + _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $pic_flag $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + else + _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~ + $CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp' + + # Both c and cxx compiler support -rpath directly + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' + fi + _LT_TAGVAR(archive_cmds_need_lc, $1)='no' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + ;; + + solaris*) + _LT_TAGVAR(no_undefined_flag, $1)=' -z defs' + if test "$GCC" = yes; then + wlarc='${wl}' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' + else + case `$CC -V 2>&1` in + *"Compilers 5.0"*) + wlarc='' + _LT_TAGVAR(archive_cmds, $1)='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp' + ;; + *) + wlarc='${wl}' + _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' + ;; + esac + fi + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + case $host_os in + solaris2.[[0-5]] | solaris2.[[0-5]].*) ;; + *) + # The compiler driver will combine and reorder linker options, + # but understands `-z linker_flag'. GCC discards it without `$wl', + # but is careful enough not to reorder. + # Supported since Solaris 2.6 (maybe 2.5.1?) + if test "$GCC" = yes; then + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' + else + _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' + fi + ;; + esac + _LT_TAGVAR(link_all_deplibs, $1)=yes + ;; + + sunos4*) + if test "x$host_vendor" = xsequent; then + # Use $CC to link under sequent, because it throws in some extra .o + # files that make .init and .fini sections work. + _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags' + else + _LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags' + fi + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + sysv4) + case $host_vendor in + sni) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_direct, $1)=yes # is this really true??? + ;; + siemens) + ## LD is ld it makes a PLAMLIB + ## CC just makes a GrossModule. + _LT_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(reload_cmds, $1)='$CC -r -o $output$reload_objs' + _LT_TAGVAR(hardcode_direct, $1)=no + ;; + motorola) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_direct, $1)=no #Motorola manual says yes, but my tests say they lie + ;; + esac + runpath_var='LD_RUN_PATH' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + sysv4.3*) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(export_dynamic_flag_spec, $1)='-Bexport' + ;; + + sysv4*MP*) + if test -d /usr/nec; then + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + runpath_var=LD_RUN_PATH + hardcode_runpath_var=yes + _LT_TAGVAR(ld_shlibs, $1)=yes + fi + ;; + + sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*) + _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + runpath_var='LD_RUN_PATH' + + if test "$GCC" = yes; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + else + _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + fi + ;; + + sysv5* | sco3.2v5* | sco5v6*) + # Note: We can NOT use -z defs as we might desire, because we do not + # link with -lc, and that would cause any symbols used from libc to + # always be unresolved, which means just about no library would + # ever link correctly. If we're not using GNU ld we use -z text + # though, which does catch some bad symbols but isn't as heavy-handed + # as -z defs. + _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' + _LT_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs' + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R,$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=':' + _LT_TAGVAR(link_all_deplibs, $1)=yes + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport' + runpath_var='LD_RUN_PATH' + + if test "$GCC" = yes; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + else + _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + fi + ;; + + uts4*) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + *) + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + + if test x$host_vendor = xsni; then + case $host in + sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Blargedynsym' + ;; + esac + fi + fi +]) +AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)]) +test "$_LT_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no + +_LT_TAGVAR(with_gnu_ld, $1)=$with_gnu_ld + +_LT_DECL([], [libext], [0], [Old archive suffix (normally "a")])dnl +_LT_DECL([], [shrext_cmds], [1], [Shared library suffix (normally ".so")])dnl +_LT_DECL([], [extract_expsyms_cmds], [2], + [The commands to extract the exported symbol list from a shared archive]) + +# +# Do we need to explicitly link libc? +# +case "x$_LT_TAGVAR(archive_cmds_need_lc, $1)" in +x|xyes) + # Assume -lc should be added + _LT_TAGVAR(archive_cmds_need_lc, $1)=yes + + if test "$enable_shared" = yes && test "$GCC" = yes; then + case $_LT_TAGVAR(archive_cmds, $1) in + *'~'*) + # FIXME: we may have to deal with multi-command sequences. + ;; + '$CC '*) + # Test whether the compiler implicitly links with -lc since on some + # systems, -lgcc has to come before -lc. If gcc already passes -lc + # to ld, don't add -lc before -lgcc. + AC_CACHE_CHECK([whether -lc should be explicitly linked in], + [lt_cv_]_LT_TAGVAR(archive_cmds_need_lc, $1), + [$RM conftest* + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + if AC_TRY_EVAL(ac_compile) 2>conftest.err; then + soname=conftest + lib=conftest + libobjs=conftest.$ac_objext + deplibs= + wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1) + pic_flag=$_LT_TAGVAR(lt_prog_compiler_pic, $1) + compiler_flags=-v + linker_flags=-v + verstring= + output_objdir=. + libname=conftest + lt_save_allow_undefined_flag=$_LT_TAGVAR(allow_undefined_flag, $1) + _LT_TAGVAR(allow_undefined_flag, $1)= + if AC_TRY_EVAL(_LT_TAGVAR(archive_cmds, $1) 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) + then + lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=no + else + lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=yes + fi + _LT_TAGVAR(allow_undefined_flag, $1)=$lt_save_allow_undefined_flag + else + cat conftest.err 1>&5 + fi + $RM conftest* + ]) + _LT_TAGVAR(archive_cmds_need_lc, $1)=$lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1) + ;; + esac + fi + ;; +esac + +_LT_TAGDECL([build_libtool_need_lc], [archive_cmds_need_lc], [0], + [Whether or not to add -lc for building shared libraries]) +_LT_TAGDECL([allow_libtool_libs_with_static_runtimes], + [enable_shared_with_static_runtimes], [0], + [Whether or not to disallow shared libs when runtime libs are static]) +_LT_TAGDECL([], [export_dynamic_flag_spec], [1], + [Compiler flag to allow reflexive dlopens]) +_LT_TAGDECL([], [whole_archive_flag_spec], [1], + [Compiler flag to generate shared objects directly from archives]) +_LT_TAGDECL([], [compiler_needs_object], [1], + [Whether the compiler copes with passing no objects directly]) +_LT_TAGDECL([], [old_archive_from_new_cmds], [2], + [Create an old-style archive from a shared archive]) +_LT_TAGDECL([], [old_archive_from_expsyms_cmds], [2], + [Create a temporary old-style archive to link instead of a shared archive]) +_LT_TAGDECL([], [archive_cmds], [2], [Commands used to build a shared archive]) +_LT_TAGDECL([], [archive_expsym_cmds], [2]) +_LT_TAGDECL([], [module_cmds], [2], + [Commands used to build a loadable module if different from building + a shared archive.]) +_LT_TAGDECL([], [module_expsym_cmds], [2]) +_LT_TAGDECL([], [with_gnu_ld], [1], + [Whether we are building with GNU ld or not]) +_LT_TAGDECL([], [allow_undefined_flag], [1], + [Flag that allows shared libraries with undefined symbols to be built]) +_LT_TAGDECL([], [no_undefined_flag], [1], + [Flag that enforces no undefined symbols]) +_LT_TAGDECL([], [hardcode_libdir_flag_spec], [1], + [Flag to hardcode $libdir into a binary during linking. + This must work even if $libdir does not exist]) +_LT_TAGDECL([], [hardcode_libdir_separator], [1], + [Whether we need a single "-rpath" flag with a separated argument]) +_LT_TAGDECL([], [hardcode_direct], [0], + [Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes + DIR into the resulting binary]) +_LT_TAGDECL([], [hardcode_direct_absolute], [0], + [Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes + DIR into the resulting binary and the resulting library dependency is + "absolute", i.e impossible to change by setting ${shlibpath_var} if the + library is relocated]) +_LT_TAGDECL([], [hardcode_minus_L], [0], + [Set to "yes" if using the -LDIR flag during linking hardcodes DIR + into the resulting binary]) +_LT_TAGDECL([], [hardcode_shlibpath_var], [0], + [Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR + into the resulting binary]) +_LT_TAGDECL([], [hardcode_automatic], [0], + [Set to "yes" if building a shared library automatically hardcodes DIR + into the library and all subsequent libraries and executables linked + against it]) +_LT_TAGDECL([], [inherit_rpath], [0], + [Set to yes if linker adds runtime paths of dependent libraries + to runtime path list]) +_LT_TAGDECL([], [link_all_deplibs], [0], + [Whether libtool must link a program against all its dependency libraries]) +_LT_TAGDECL([], [always_export_symbols], [0], + [Set to "yes" if exported symbols are required]) +_LT_TAGDECL([], [export_symbols_cmds], [2], + [The commands to list exported symbols]) +_LT_TAGDECL([], [exclude_expsyms], [1], + [Symbols that should not be listed in the preloaded symbols]) +_LT_TAGDECL([], [include_expsyms], [1], + [Symbols that must always be exported]) +_LT_TAGDECL([], [prelink_cmds], [2], + [Commands necessary for linking programs (against libraries) with templates]) +_LT_TAGDECL([], [postlink_cmds], [2], + [Commands necessary for finishing linking programs]) +_LT_TAGDECL([], [file_list_spec], [1], + [Specify filename containing input files]) +dnl FIXME: Not yet implemented +dnl _LT_TAGDECL([], [thread_safe_flag_spec], [1], +dnl [Compiler flag to generate thread safe objects]) +])# _LT_LINKER_SHLIBS + + +# _LT_LANG_C_CONFIG([TAG]) +# ------------------------ +# Ensure that the configuration variables for a C compiler are suitably +# defined. These variables are subsequently used by _LT_CONFIG to write +# the compiler configuration to `libtool'. +m4_defun([_LT_LANG_C_CONFIG], +[m4_require([_LT_DECL_EGREP])dnl +lt_save_CC="$CC" +AC_LANG_PUSH(C) + +# Source file extension for C test sources. +ac_ext=c + +# Object file extension for compiled C test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code="int some_variable = 0;" + +# Code to be used in simple link tests +lt_simple_link_test_code='int main(){return(0);}' + +_LT_TAG_COMPILER +# Save the default compiler, since it gets overwritten when the other +# tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP. +compiler_DEFAULT=$CC + +# save warnings/boilerplate of simple test code +_LT_COMPILER_BOILERPLATE +_LT_LINKER_BOILERPLATE + +## CAVEAT EMPTOR: +## There is no encapsulation within the following macros, do not change +## the running order or otherwise move them around unless you know exactly +## what you are doing... +if test -n "$compiler"; then + _LT_COMPILER_NO_RTTI($1) + _LT_COMPILER_PIC($1) + _LT_COMPILER_C_O($1) + _LT_COMPILER_FILE_LOCKS($1) + _LT_LINKER_SHLIBS($1) + _LT_SYS_DYNAMIC_LINKER($1) + _LT_LINKER_HARDCODE_LIBPATH($1) + LT_SYS_DLOPEN_SELF + _LT_CMD_STRIPLIB + + # Report which library types will actually be built + AC_MSG_CHECKING([if libtool supports shared libraries]) + AC_MSG_RESULT([$can_build_shared]) + + AC_MSG_CHECKING([whether to build shared libraries]) + test "$can_build_shared" = "no" && enable_shared=no + + # On AIX, shared libraries and static libraries use the same namespace, and + # are all built from PIC. + case $host_os in + aix3*) + test "$enable_shared" = yes && enable_static=no + if test -n "$RANLIB"; then + archive_cmds="$archive_cmds~\$RANLIB \$lib" + postinstall_cmds='$RANLIB $lib' + fi + ;; + + aix[[4-9]]*) + if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then + test "$enable_shared" = yes && enable_static=no + fi + ;; + esac + AC_MSG_RESULT([$enable_shared]) + + AC_MSG_CHECKING([whether to build static libraries]) + # Make sure either enable_shared or enable_static is yes. + test "$enable_shared" = yes || enable_static=yes + AC_MSG_RESULT([$enable_static]) + + _LT_CONFIG($1) +fi +AC_LANG_POP +CC="$lt_save_CC" +])# _LT_LANG_C_CONFIG + + +# _LT_LANG_CXX_CONFIG([TAG]) +# -------------------------- +# Ensure that the configuration variables for a C++ compiler are suitably +# defined. These variables are subsequently used by _LT_CONFIG to write +# the compiler configuration to `libtool'. +m4_defun([_LT_LANG_CXX_CONFIG], +[m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_DECL_EGREP])dnl +m4_require([_LT_PATH_MANIFEST_TOOL])dnl +if test -n "$CXX" && ( test "X$CXX" != "Xno" && + ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) || + (test "X$CXX" != "Xg++"))) ; then + AC_PROG_CXXCPP +else + _lt_caught_CXX_error=yes +fi + +AC_LANG_PUSH(C++) +_LT_TAGVAR(archive_cmds_need_lc, $1)=no +_LT_TAGVAR(allow_undefined_flag, $1)= +_LT_TAGVAR(always_export_symbols, $1)=no +_LT_TAGVAR(archive_expsym_cmds, $1)= +_LT_TAGVAR(compiler_needs_object, $1)=no +_LT_TAGVAR(export_dynamic_flag_spec, $1)= +_LT_TAGVAR(hardcode_direct, $1)=no +_LT_TAGVAR(hardcode_direct_absolute, $1)=no +_LT_TAGVAR(hardcode_libdir_flag_spec, $1)= +_LT_TAGVAR(hardcode_libdir_separator, $1)= +_LT_TAGVAR(hardcode_minus_L, $1)=no +_LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported +_LT_TAGVAR(hardcode_automatic, $1)=no +_LT_TAGVAR(inherit_rpath, $1)=no +_LT_TAGVAR(module_cmds, $1)= +_LT_TAGVAR(module_expsym_cmds, $1)= +_LT_TAGVAR(link_all_deplibs, $1)=unknown +_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds +_LT_TAGVAR(reload_flag, $1)=$reload_flag +_LT_TAGVAR(reload_cmds, $1)=$reload_cmds +_LT_TAGVAR(no_undefined_flag, $1)= +_LT_TAGVAR(whole_archive_flag_spec, $1)= +_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no + +# Source file extension for C++ test sources. +ac_ext=cpp + +# Object file extension for compiled C++ test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# No sense in running all these tests if we already determined that +# the CXX compiler isn't working. Some variables (like enable_shared) +# are currently assumed to apply to all compilers on this platform, +# and will be corrupted by setting them based on a non-working compiler. +if test "$_lt_caught_CXX_error" != yes; then + # Code to be used in simple compile tests + lt_simple_compile_test_code="int some_variable = 0;" + + # Code to be used in simple link tests + lt_simple_link_test_code='int main(int, char *[[]]) { return(0); }' + + # ltmain only uses $CC for tagged configurations so make sure $CC is set. + _LT_TAG_COMPILER + + # save warnings/boilerplate of simple test code + _LT_COMPILER_BOILERPLATE + _LT_LINKER_BOILERPLATE + + # Allow CC to be a program name with arguments. + lt_save_CC=$CC + lt_save_CFLAGS=$CFLAGS + lt_save_LD=$LD + lt_save_GCC=$GCC + GCC=$GXX + lt_save_with_gnu_ld=$with_gnu_ld + lt_save_path_LD=$lt_cv_path_LD + if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then + lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx + else + $as_unset lt_cv_prog_gnu_ld + fi + if test -n "${lt_cv_path_LDCXX+set}"; then + lt_cv_path_LD=$lt_cv_path_LDCXX + else + $as_unset lt_cv_path_LD + fi + test -z "${LDCXX+set}" || LD=$LDCXX + CC=${CXX-"c++"} + CFLAGS=$CXXFLAGS + compiler=$CC + _LT_TAGVAR(compiler, $1)=$CC + _LT_CC_BASENAME([$compiler]) + + if test -n "$compiler"; then + # We don't want -fno-exception when compiling C++ code, so set the + # no_builtin_flag separately + if test "$GXX" = yes; then + _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin' + else + _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)= + fi + + if test "$GXX" = yes; then + # Set up default GNU C++ configuration + + LT_PATH_LD + + # Check if GNU C++ uses GNU ld as the underlying linker, since the + # archiving commands below assume that GNU ld is being used. + if test "$with_gnu_ld" = yes; then + _LT_TAGVAR(archive_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + + # If archive_cmds runs LD, not CC, wlarc should be empty + # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to + # investigate it a little bit more. (MM) + wlarc='${wl}' + + # ancient GNU ld didn't support --whole-archive et. al. + if eval "`$CC -print-prog-name=ld` --help 2>&1" | + $GREP 'no-whole-archive' > /dev/null; then + _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + else + _LT_TAGVAR(whole_archive_flag_spec, $1)= + fi + else + with_gnu_ld=no + wlarc= + + # A generic and very simple default shared library creation + # command for GNU C++ for the case where it uses the native + # linker, instead of GNU ld. If possible, this setting should + # overridden to take advantage of the native linker features on + # the platform it is being used on. + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' + fi + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + + else + GXX=no + with_gnu_ld=no + wlarc= + fi + + # PORTME: fill in a description of your system's C++ link characteristics + AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries]) + _LT_TAGVAR(ld_shlibs, $1)=yes + case $host_os in + aix3*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + aix[[4-9]]*) + if test "$host_cpu" = ia64; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag="" + else + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # need to do runtime linking. + case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*) + for ld_flag in $LDFLAGS; do + case $ld_flag in + *-brtl*) + aix_use_runtimelinking=yes + break + ;; + esac + done + ;; + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + _LT_TAGVAR(archive_cmds, $1)='' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(hardcode_libdir_separator, $1)=':' + _LT_TAGVAR(link_all_deplibs, $1)=yes + _LT_TAGVAR(file_list_spec, $1)='${wl}-f,' + + if test "$GXX" = yes; then + case $host_os in aix4.[[012]]|aix4.[[012]].*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`${CC} -print-prog-name=collect2` + if test -f "$collect2name" && + strings "$collect2name" | $GREP resolve_lib_name >/dev/null + then + # We have reworked collect2 + : + else + # We have old collect2 + _LT_TAGVAR(hardcode_direct, $1)=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)= + fi + esac + shared_flag='-shared' + if test "$aix_use_runtimelinking" = yes; then + shared_flag="$shared_flag "'${wl}-G' + fi + else + # not using gcc + if test "$host_cpu" = ia64; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test "$aix_use_runtimelinking" = yes; then + shared_flag='${wl}-G' + else + shared_flag='${wl}-bM:SRE' + fi + fi + fi + + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-bexpall' + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to + # export. + _LT_TAGVAR(always_export_symbols, $1)=yes + if test "$aix_use_runtimelinking" = yes; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + _LT_TAGVAR(allow_undefined_flag, $1)='-berok' + # Determine the default libpath from the value encoded in an empty + # executable. + _LT_SYS_MODULE_PATH_AIX([$1]) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" + + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag" + else + if test "$host_cpu" = ia64; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib' + _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs" + _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an + # empty executable. + _LT_SYS_MODULE_PATH_AIX([$1]) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok' + _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok' + if test "$with_gnu_ld" = yes; then + # We only use this code for GNU lds that support --whole-archive. + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + else + # Exported symbols can be pulled into shared objects from archives + _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience' + fi + _LT_TAGVAR(archive_cmds_need_lc, $1)=yes + # This is similar to how AIX traditionally builds its shared + # libraries. + _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + fi + fi + ;; + + beos*) + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + # Joseph Beckenbach says some releases of gcc + # support --undefined. This deserves some investigation. FIXME + _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + chorus*) + case $cc_basename in + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + + cygwin* | mingw* | pw32* | cegcc*) + case $GXX,$cc_basename in + ,cl* | no,cl*) + # Native MSVC + # hardcode_libdir_flag_spec is actually meaningless, as there is + # no search path for DLLs. + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' ' + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_TAGVAR(always_export_symbols, $1)=yes + _LT_TAGVAR(file_list_spec, $1)='@' + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames=' + _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + $SED -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp; + else + $SED -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp; + fi~ + $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ + linknames=' + # The linker will not automatically build a static lib if we build a DLL. + # _LT_TAGVAR(old_archive_from_new_cmds, $1)='true' + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + # Don't use ranlib + _LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib' + _LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~ + lt_tool_outputfile="@TOOL_OUTPUT@"~ + case $lt_outputfile in + *.exe|*.EXE) ;; + *) + lt_outputfile="$lt_outputfile.exe" + lt_tool_outputfile="$lt_tool_outputfile.exe" + ;; + esac~ + func_to_tool_file "$lt_outputfile"~ + if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then + $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; + $RM "$lt_outputfile.manifest"; + fi' + ;; + *) + # g++ + # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless, + # as there is no search path for DLLs. + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-all-symbols' + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_TAGVAR(always_export_symbols, $1)=no + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + + if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + # If the export-symbols file already is a .def file (1st line + # is EXPORTS), use it as is; otherwise, prepend... + _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + ;; + darwin* | rhapsody*) + _LT_DARWIN_LINKER_FEATURES($1) + ;; + + dgux*) + case $cc_basename in + ec++*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + ghcx*) + # Green Hills C++ Compiler + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + + freebsd2.*) + # C++ shared libraries reported to be fairly broken before + # switch to ELF + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + + freebsd-elf*) + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + ;; + + freebsd* | dragonfly*) + # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF + # conventions + _LT_TAGVAR(ld_shlibs, $1)=yes + ;; + + haiku*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(link_all_deplibs, $1)=yes + ;; + + hpux9*) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH, + # but as the default + # location of the library. + + case $cc_basename in + CC*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + aCC*) + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + ;; + *) + if test "$GXX" = yes; then + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + else + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + ;; + + hpux10*|hpux11*) + if test $with_gnu_ld = no; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + case $host_cpu in + hppa*64*|ia64*) + ;; + *) + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + ;; + esac + fi + case $host_cpu in + hppa*64*|ia64*) + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + *) + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH, + # but as the default + # location of the library. + ;; + esac + + case $cc_basename in + CC*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + aCC*) + case $host_cpu in + hppa*64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + ia64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + esac + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + ;; + *) + if test "$GXX" = yes; then + if test $with_gnu_ld = no; then + case $host_cpu in + hppa*64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + ia64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + esac + fi + else + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + ;; + + interix[[3-9]]*) + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc. + # Instead, shared libraries are loaded at an image base (0x10000000 by + # default) and relocated if they conflict, which is a slow very memory + # consuming and fragmenting process. To avoid this, we pick a random, + # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link + # time. Moving up from 0x10000000 also allows more sbrk(2) space. + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + ;; + irix5* | irix6*) + case $cc_basename in + CC*) + # SGI C++ + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + + # Archives containing C++ object files must be created using + # "CC -ar", where "CC" is the IRIX C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + _LT_TAGVAR(old_archive_cmds, $1)='$CC -ar -WR,-u -o $oldlib $oldobjs' + ;; + *) + if test "$GXX" = yes; then + if test "$with_gnu_ld" = no; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` -o $lib' + fi + fi + _LT_TAGVAR(link_all_deplibs, $1)=yes + ;; + esac + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_TAGVAR(inherit_rpath, $1)=yes + ;; + + linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + case $cc_basename in + KCC*) + # Kuck and Associates, Inc. (KAI) C++ Compiler + + # KCC will only create a shared library if the output file + # ends with ".so" (or ".sl" for HP-UX), so rename the library + # to its proper name (with version) after linking. + _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib' + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + + # Archives containing C++ object files must be created using + # "CC -Bstatic", where "CC" is the KAI C++ compiler. + _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs' + ;; + icpc* | ecpc* ) + # Intel C++ + with_gnu_ld=yes + # version 8.0 and above of icpc choke on multiply defined symbols + # if we add $predep_objects and $postdep_objects, however 7.1 and + # earlier do not add the objects themselves. + case `$CC -V 2>&1` in + *"Version 7."*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + ;; + *) # Version 8.0 or newer + tmp_idyn= + case $host_cpu in + ia64*) tmp_idyn=' -i_dynamic';; + esac + _LT_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + ;; + esac + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + ;; + pgCC* | pgcpp*) + # Portland Group C++ compiler + case `$CC -V` in + *pgCC\ [[1-5]].* | *pgcpp\ [[1-5]].*) + _LT_TAGVAR(prelink_cmds, $1)='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~ + compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"' + _LT_TAGVAR(old_archive_cmds, $1)='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~ + $AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~ + $RANLIB $oldlib' + _LT_TAGVAR(archive_cmds, $1)='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ + $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ + $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib' + ;; + *) # Version 6 and above use weak symbols + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib' + ;; + esac + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + ;; + cxx*) + # Compaq C++ + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib ${wl}-retain-symbols-file $wl$export_symbols' + + runpath_var=LD_RUN_PATH + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed' + ;; + xl* | mpixl* | bgxl*) + # IBM XL 8.0 on PPC, with GNU ld + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + _LT_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + if test "x$supports_anon_versioning" = xyes; then + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~ + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' + fi + ;; + *) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) + # Sun C++ 5.9 + _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs' + _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file ${wl}$export_symbols' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + _LT_TAGVAR(compiler_needs_object, $1)=yes + + # Not sure whether something based on + # $CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 + # would be better. + output_verbose_link_cmd='func_echo_all' + + # Archives containing C++ object files must be created using + # "CC -xar", where "CC" is the Sun C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs' + ;; + esac + ;; + esac + ;; + + lynxos*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + + m88k*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + + mvs*) + case $cc_basename in + cxx*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + + netbsd*) + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags' + wlarc= + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + fi + # Workaround some broken pre-1.5 toolchains + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"' + ;; + + *nto* | *qnx*) + _LT_TAGVAR(ld_shlibs, $1)=yes + ;; + + openbsd2*) + # C++ shared libraries are fairly broken + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + + openbsd*) + if test -f /usr/libexec/ld.so; then + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + fi + output_verbose_link_cmd=func_echo_all + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + osf3* | osf4* | osf5*) + case $cc_basename in + KCC*) + # Kuck and Associates, Inc. (KAI) C++ Compiler + + # KCC will only create a shared library if the output file + # ends with ".so" (or ".sl" for HP-UX), so rename the library + # to its proper name (with version) after linking. + _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + # Archives containing C++ object files must be created using + # the KAI C++ compiler. + case $host in + osf3*) _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs' ;; + *) _LT_TAGVAR(old_archive_cmds, $1)='$CC -o $oldlib $oldobjs' ;; + esac + ;; + RCC*) + # Rational C++ 2.4.1 + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + cxx*) + case $host in + osf3*) + _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && func_echo_all "${wl}-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + ;; + *) + _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~ + echo "-hidden">> $lib.exp~ + $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname ${wl}-input ${wl}$lib.exp `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~ + $RM $lib.exp' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' + ;; + esac + + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + ;; + *) + if test "$GXX" = yes && test "$with_gnu_ld" = no; then + _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' + case $host in + osf3*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + ;; + esac + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + + else + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + ;; + + psos*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + + sunos4*) + case $cc_basename in + CC*) + # Sun C++ 4.x + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + lcc*) + # Lucid + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + + solaris*) + case $cc_basename in + CC* | sunCC*) + # Sun C++ 4.2, 5.x and Centerline C++ + _LT_TAGVAR(archive_cmds_need_lc,$1)=yes + _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs' + _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -G${allow_undefined_flag} ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + case $host_os in + solaris2.[[0-5]] | solaris2.[[0-5]].*) ;; + *) + # The compiler driver will combine and reorder linker options, + # but understands `-z linker_flag'. + # Supported since Solaris 2.6 (maybe 2.5.1?) + _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' + ;; + esac + _LT_TAGVAR(link_all_deplibs, $1)=yes + + output_verbose_link_cmd='func_echo_all' + + # Archives containing C++ object files must be created using + # "CC -xar", where "CC" is the Sun C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs' + ;; + gcx*) + # Green Hills C++ Compiler + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + + # The C++ compiler must be used to create the archive. + _LT_TAGVAR(old_archive_cmds, $1)='$CC $LDFLAGS -archive -o $oldlib $oldobjs' + ;; + *) + # GNU C++ compiler with Solaris linker + if test "$GXX" = yes && test "$with_gnu_ld" = no; then + _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-z ${wl}defs' + if $CC --version | $GREP -v '^2\.7' > /dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -shared $pic_flag -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + else + # g++ 2.7 appears to require `-G' NOT `-shared' on this + # platform. + _LT_TAGVAR(archive_cmds, $1)='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + fi + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $wl$libdir' + case $host_os in + solaris2.[[0-5]] | solaris2.[[0-5]].*) ;; + *) + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' + ;; + esac + fi + ;; + esac + ;; + + sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*) + _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + runpath_var='LD_RUN_PATH' + + case $cc_basename in + CC*) + _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + ;; + + sysv5* | sco3.2v5* | sco5v6*) + # Note: We can NOT use -z defs as we might desire, because we do not + # link with -lc, and that would cause any symbols used from libc to + # always be unresolved, which means just about no library would + # ever link correctly. If we're not using GNU ld we use -z text + # though, which does catch some bad symbols but isn't as heavy-handed + # as -z defs. + _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' + _LT_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs' + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R,$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=':' + _LT_TAGVAR(link_all_deplibs, $1)=yes + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport' + runpath_var='LD_RUN_PATH' + + case $cc_basename in + CC*) + _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(old_archive_cmds, $1)='$CC -Tprelink_objects $oldobjs~ + '"$_LT_TAGVAR(old_archive_cmds, $1)" + _LT_TAGVAR(reload_cmds, $1)='$CC -Tprelink_objects $reload_objs~ + '"$_LT_TAGVAR(reload_cmds, $1)" + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + ;; + + tandem*) + case $cc_basename in + NCC*) + # NonStop-UX NCC 3.20 + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + + vxworks*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + + AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)]) + test "$_LT_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no + + _LT_TAGVAR(GCC, $1)="$GXX" + _LT_TAGVAR(LD, $1)="$LD" + + ## CAVEAT EMPTOR: + ## There is no encapsulation within the following macros, do not change + ## the running order or otherwise move them around unless you know exactly + ## what you are doing... + _LT_SYS_HIDDEN_LIBDEPS($1) + _LT_COMPILER_PIC($1) + _LT_COMPILER_C_O($1) + _LT_COMPILER_FILE_LOCKS($1) + _LT_LINKER_SHLIBS($1) + _LT_SYS_DYNAMIC_LINKER($1) + _LT_LINKER_HARDCODE_LIBPATH($1) + + _LT_CONFIG($1) + fi # test -n "$compiler" + + CC=$lt_save_CC + CFLAGS=$lt_save_CFLAGS + LDCXX=$LD + LD=$lt_save_LD + GCC=$lt_save_GCC + with_gnu_ld=$lt_save_with_gnu_ld + lt_cv_path_LDCXX=$lt_cv_path_LD + lt_cv_path_LD=$lt_save_path_LD + lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld + lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld +fi # test "$_lt_caught_CXX_error" != yes + +AC_LANG_POP +])# _LT_LANG_CXX_CONFIG + + +# _LT_FUNC_STRIPNAME_CNF +# ---------------------- +# func_stripname_cnf prefix suffix name +# strip PREFIX and SUFFIX off of NAME. +# PREFIX and SUFFIX must not contain globbing or regex special +# characters, hashes, percent signs, but SUFFIX may contain a leading +# dot (in which case that matches only a dot). +# +# This function is identical to the (non-XSI) version of func_stripname, +# except this one can be used by m4 code that may be executed by configure, +# rather than the libtool script. +m4_defun([_LT_FUNC_STRIPNAME_CNF],[dnl +AC_REQUIRE([_LT_DECL_SED]) +AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH]) +func_stripname_cnf () +{ + case ${2} in + .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;; + *) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;; + esac +} # func_stripname_cnf +])# _LT_FUNC_STRIPNAME_CNF + +# _LT_SYS_HIDDEN_LIBDEPS([TAGNAME]) +# --------------------------------- +# Figure out "hidden" library dependencies from verbose +# compiler output when linking a shared library. +# Parse the compiler output and extract the necessary +# objects, libraries and library flags. +m4_defun([_LT_SYS_HIDDEN_LIBDEPS], +[m4_require([_LT_FILEUTILS_DEFAULTS])dnl +AC_REQUIRE([_LT_FUNC_STRIPNAME_CNF])dnl +# Dependencies to place before and after the object being linked: +_LT_TAGVAR(predep_objects, $1)= +_LT_TAGVAR(postdep_objects, $1)= +_LT_TAGVAR(predeps, $1)= +_LT_TAGVAR(postdeps, $1)= +_LT_TAGVAR(compiler_lib_search_path, $1)= + +dnl we can't use the lt_simple_compile_test_code here, +dnl because it contains code intended for an executable, +dnl not a library. It's possible we should let each +dnl tag define a new lt_????_link_test_code variable, +dnl but it's only used here... +m4_if([$1], [], [cat > conftest.$ac_ext <<_LT_EOF +int a; +void foo (void) { a = 0; } +_LT_EOF +], [$1], [CXX], [cat > conftest.$ac_ext <<_LT_EOF +class Foo +{ +public: + Foo (void) { a = 0; } +private: + int a; +}; +_LT_EOF +], [$1], [F77], [cat > conftest.$ac_ext <<_LT_EOF + subroutine foo + implicit none + integer*4 a + a=0 + return + end +_LT_EOF +], [$1], [FC], [cat > conftest.$ac_ext <<_LT_EOF + subroutine foo + implicit none + integer a + a=0 + return + end +_LT_EOF +], [$1], [GCJ], [cat > conftest.$ac_ext <<_LT_EOF +public class foo { + private int a; + public void bar (void) { + a = 0; + } +}; +_LT_EOF +], [$1], [GO], [cat > conftest.$ac_ext <<_LT_EOF +package foo +func foo() { +} +_LT_EOF +]) + +_lt_libdeps_save_CFLAGS=$CFLAGS +case "$CC $CFLAGS " in #( +*\ -flto*\ *) CFLAGS="$CFLAGS -fno-lto" ;; +*\ -fwhopr*\ *) CFLAGS="$CFLAGS -fno-whopr" ;; +*\ -fuse-linker-plugin*\ *) CFLAGS="$CFLAGS -fno-use-linker-plugin" ;; +esac + +dnl Parse the compiler output and extract the necessary +dnl objects, libraries and library flags. +if AC_TRY_EVAL(ac_compile); then + # Parse the compiler output and extract the necessary + # objects, libraries and library flags. + + # Sentinel used to keep track of whether or not we are before + # the conftest object file. + pre_test_object_deps_done=no + + for p in `eval "$output_verbose_link_cmd"`; do + case ${prev}${p} in + + -L* | -R* | -l*) + # Some compilers place space between "-{L,R}" and the path. + # Remove the space. + if test $p = "-L" || + test $p = "-R"; then + prev=$p + continue + fi + + # Expand the sysroot to ease extracting the directories later. + if test -z "$prev"; then + case $p in + -L*) func_stripname_cnf '-L' '' "$p"; prev=-L; p=$func_stripname_result ;; + -R*) func_stripname_cnf '-R' '' "$p"; prev=-R; p=$func_stripname_result ;; + -l*) func_stripname_cnf '-l' '' "$p"; prev=-l; p=$func_stripname_result ;; + esac + fi + case $p in + =*) func_stripname_cnf '=' '' "$p"; p=$lt_sysroot$func_stripname_result ;; + esac + if test "$pre_test_object_deps_done" = no; then + case ${prev} in + -L | -R) + # Internal compiler library paths should come after those + # provided the user. The postdeps already come after the + # user supplied libs so there is no need to process them. + if test -z "$_LT_TAGVAR(compiler_lib_search_path, $1)"; then + _LT_TAGVAR(compiler_lib_search_path, $1)="${prev}${p}" + else + _LT_TAGVAR(compiler_lib_search_path, $1)="${_LT_TAGVAR(compiler_lib_search_path, $1)} ${prev}${p}" + fi + ;; + # The "-l" case would never come before the object being + # linked, so don't bother handling this case. + esac + else + if test -z "$_LT_TAGVAR(postdeps, $1)"; then + _LT_TAGVAR(postdeps, $1)="${prev}${p}" + else + _LT_TAGVAR(postdeps, $1)="${_LT_TAGVAR(postdeps, $1)} ${prev}${p}" + fi + fi + prev= + ;; + + *.lto.$objext) ;; # Ignore GCC LTO objects + *.$objext) + # This assumes that the test object file only shows up + # once in the compiler output. + if test "$p" = "conftest.$objext"; then + pre_test_object_deps_done=yes + continue + fi + + if test "$pre_test_object_deps_done" = no; then + if test -z "$_LT_TAGVAR(predep_objects, $1)"; then + _LT_TAGVAR(predep_objects, $1)="$p" + else + _LT_TAGVAR(predep_objects, $1)="$_LT_TAGVAR(predep_objects, $1) $p" + fi + else + if test -z "$_LT_TAGVAR(postdep_objects, $1)"; then + _LT_TAGVAR(postdep_objects, $1)="$p" + else + _LT_TAGVAR(postdep_objects, $1)="$_LT_TAGVAR(postdep_objects, $1) $p" + fi + fi + ;; + + *) ;; # Ignore the rest. + + esac + done + + # Clean up. + rm -f a.out a.exe +else + echo "libtool.m4: error: problem compiling $1 test program" +fi + +$RM -f confest.$objext +CFLAGS=$_lt_libdeps_save_CFLAGS + +# PORTME: override above test on systems where it is broken +m4_if([$1], [CXX], +[case $host_os in +interix[[3-9]]*) + # Interix 3.5 installs completely hosed .la files for C++, so rather than + # hack all around it, let's just trust "g++" to DTRT. + _LT_TAGVAR(predep_objects,$1)= + _LT_TAGVAR(postdep_objects,$1)= + _LT_TAGVAR(postdeps,$1)= + ;; + +linux*) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) + # Sun C++ 5.9 + + # The more standards-conforming stlport4 library is + # incompatible with the Cstd library. Avoid specifying + # it if it's in CXXFLAGS. Ignore libCrun as + # -library=stlport4 depends on it. + case " $CXX $CXXFLAGS " in + *" -library=stlport4 "*) + solaris_use_stlport4=yes + ;; + esac + + if test "$solaris_use_stlport4" != yes; then + _LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun' + fi + ;; + esac + ;; + +solaris*) + case $cc_basename in + CC* | sunCC*) + # The more standards-conforming stlport4 library is + # incompatible with the Cstd library. Avoid specifying + # it if it's in CXXFLAGS. Ignore libCrun as + # -library=stlport4 depends on it. + case " $CXX $CXXFLAGS " in + *" -library=stlport4 "*) + solaris_use_stlport4=yes + ;; + esac + + # Adding this requires a known-good setup of shared libraries for + # Sun compiler versions before 5.6, else PIC objects from an old + # archive will be linked into the output, leading to subtle bugs. + if test "$solaris_use_stlport4" != yes; then + _LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun' + fi + ;; + esac + ;; +esac +]) + +case " $_LT_TAGVAR(postdeps, $1) " in +*" -lc "*) _LT_TAGVAR(archive_cmds_need_lc, $1)=no ;; +esac + _LT_TAGVAR(compiler_lib_search_dirs, $1)= +if test -n "${_LT_TAGVAR(compiler_lib_search_path, $1)}"; then + _LT_TAGVAR(compiler_lib_search_dirs, $1)=`echo " ${_LT_TAGVAR(compiler_lib_search_path, $1)}" | ${SED} -e 's! -L! !g' -e 's!^ !!'` +fi +_LT_TAGDECL([], [compiler_lib_search_dirs], [1], + [The directories searched by this compiler when creating a shared library]) +_LT_TAGDECL([], [predep_objects], [1], + [Dependencies to place before and after the objects being linked to + create a shared library]) +_LT_TAGDECL([], [postdep_objects], [1]) +_LT_TAGDECL([], [predeps], [1]) +_LT_TAGDECL([], [postdeps], [1]) +_LT_TAGDECL([], [compiler_lib_search_path], [1], + [The library search path used internally by the compiler when linking + a shared library]) +])# _LT_SYS_HIDDEN_LIBDEPS + + +# _LT_LANG_F77_CONFIG([TAG]) +# -------------------------- +# Ensure that the configuration variables for a Fortran 77 compiler are +# suitably defined. These variables are subsequently used by _LT_CONFIG +# to write the compiler configuration to `libtool'. +m4_defun([_LT_LANG_F77_CONFIG], +[AC_LANG_PUSH(Fortran 77) +if test -z "$F77" || test "X$F77" = "Xno"; then + _lt_disable_F77=yes +fi + +_LT_TAGVAR(archive_cmds_need_lc, $1)=no +_LT_TAGVAR(allow_undefined_flag, $1)= +_LT_TAGVAR(always_export_symbols, $1)=no +_LT_TAGVAR(archive_expsym_cmds, $1)= +_LT_TAGVAR(export_dynamic_flag_spec, $1)= +_LT_TAGVAR(hardcode_direct, $1)=no +_LT_TAGVAR(hardcode_direct_absolute, $1)=no +_LT_TAGVAR(hardcode_libdir_flag_spec, $1)= +_LT_TAGVAR(hardcode_libdir_separator, $1)= +_LT_TAGVAR(hardcode_minus_L, $1)=no +_LT_TAGVAR(hardcode_automatic, $1)=no +_LT_TAGVAR(inherit_rpath, $1)=no +_LT_TAGVAR(module_cmds, $1)= +_LT_TAGVAR(module_expsym_cmds, $1)= +_LT_TAGVAR(link_all_deplibs, $1)=unknown +_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds +_LT_TAGVAR(reload_flag, $1)=$reload_flag +_LT_TAGVAR(reload_cmds, $1)=$reload_cmds +_LT_TAGVAR(no_undefined_flag, $1)= +_LT_TAGVAR(whole_archive_flag_spec, $1)= +_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no + +# Source file extension for f77 test sources. +ac_ext=f + +# Object file extension for compiled f77 test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# No sense in running all these tests if we already determined that +# the F77 compiler isn't working. Some variables (like enable_shared) +# are currently assumed to apply to all compilers on this platform, +# and will be corrupted by setting them based on a non-working compiler. +if test "$_lt_disable_F77" != yes; then + # Code to be used in simple compile tests + lt_simple_compile_test_code="\ + subroutine t + return + end +" + + # Code to be used in simple link tests + lt_simple_link_test_code="\ + program t + end +" + + # ltmain only uses $CC for tagged configurations so make sure $CC is set. + _LT_TAG_COMPILER + + # save warnings/boilerplate of simple test code + _LT_COMPILER_BOILERPLATE + _LT_LINKER_BOILERPLATE + + # Allow CC to be a program name with arguments. + lt_save_CC="$CC" + lt_save_GCC=$GCC + lt_save_CFLAGS=$CFLAGS + CC=${F77-"f77"} + CFLAGS=$FFLAGS + compiler=$CC + _LT_TAGVAR(compiler, $1)=$CC + _LT_CC_BASENAME([$compiler]) + GCC=$G77 + if test -n "$compiler"; then + AC_MSG_CHECKING([if libtool supports shared libraries]) + AC_MSG_RESULT([$can_build_shared]) + + AC_MSG_CHECKING([whether to build shared libraries]) + test "$can_build_shared" = "no" && enable_shared=no + + # On AIX, shared libraries and static libraries use the same namespace, and + # are all built from PIC. + case $host_os in + aix3*) + test "$enable_shared" = yes && enable_static=no + if test -n "$RANLIB"; then + archive_cmds="$archive_cmds~\$RANLIB \$lib" + postinstall_cmds='$RANLIB $lib' + fi + ;; + aix[[4-9]]*) + if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then + test "$enable_shared" = yes && enable_static=no + fi + ;; + esac + AC_MSG_RESULT([$enable_shared]) + + AC_MSG_CHECKING([whether to build static libraries]) + # Make sure either enable_shared or enable_static is yes. + test "$enable_shared" = yes || enable_static=yes + AC_MSG_RESULT([$enable_static]) + + _LT_TAGVAR(GCC, $1)="$G77" + _LT_TAGVAR(LD, $1)="$LD" + + ## CAVEAT EMPTOR: + ## There is no encapsulation within the following macros, do not change + ## the running order or otherwise move them around unless you know exactly + ## what you are doing... + _LT_COMPILER_PIC($1) + _LT_COMPILER_C_O($1) + _LT_COMPILER_FILE_LOCKS($1) + _LT_LINKER_SHLIBS($1) + _LT_SYS_DYNAMIC_LINKER($1) + _LT_LINKER_HARDCODE_LIBPATH($1) + + _LT_CONFIG($1) + fi # test -n "$compiler" + + GCC=$lt_save_GCC + CC="$lt_save_CC" + CFLAGS="$lt_save_CFLAGS" +fi # test "$_lt_disable_F77" != yes + +AC_LANG_POP +])# _LT_LANG_F77_CONFIG + + +# _LT_LANG_FC_CONFIG([TAG]) +# ------------------------- +# Ensure that the configuration variables for a Fortran compiler are +# suitably defined. These variables are subsequently used by _LT_CONFIG +# to write the compiler configuration to `libtool'. +m4_defun([_LT_LANG_FC_CONFIG], +[AC_LANG_PUSH(Fortran) + +if test -z "$FC" || test "X$FC" = "Xno"; then + _lt_disable_FC=yes +fi + +_LT_TAGVAR(archive_cmds_need_lc, $1)=no +_LT_TAGVAR(allow_undefined_flag, $1)= +_LT_TAGVAR(always_export_symbols, $1)=no +_LT_TAGVAR(archive_expsym_cmds, $1)= +_LT_TAGVAR(export_dynamic_flag_spec, $1)= +_LT_TAGVAR(hardcode_direct, $1)=no +_LT_TAGVAR(hardcode_direct_absolute, $1)=no +_LT_TAGVAR(hardcode_libdir_flag_spec, $1)= +_LT_TAGVAR(hardcode_libdir_separator, $1)= +_LT_TAGVAR(hardcode_minus_L, $1)=no +_LT_TAGVAR(hardcode_automatic, $1)=no +_LT_TAGVAR(inherit_rpath, $1)=no +_LT_TAGVAR(module_cmds, $1)= +_LT_TAGVAR(module_expsym_cmds, $1)= +_LT_TAGVAR(link_all_deplibs, $1)=unknown +_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds +_LT_TAGVAR(reload_flag, $1)=$reload_flag +_LT_TAGVAR(reload_cmds, $1)=$reload_cmds +_LT_TAGVAR(no_undefined_flag, $1)= +_LT_TAGVAR(whole_archive_flag_spec, $1)= +_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no + +# Source file extension for fc test sources. +ac_ext=${ac_fc_srcext-f} + +# Object file extension for compiled fc test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# No sense in running all these tests if we already determined that +# the FC compiler isn't working. Some variables (like enable_shared) +# are currently assumed to apply to all compilers on this platform, +# and will be corrupted by setting them based on a non-working compiler. +if test "$_lt_disable_FC" != yes; then + # Code to be used in simple compile tests + lt_simple_compile_test_code="\ + subroutine t + return + end +" + + # Code to be used in simple link tests + lt_simple_link_test_code="\ + program t + end +" + + # ltmain only uses $CC for tagged configurations so make sure $CC is set. + _LT_TAG_COMPILER + + # save warnings/boilerplate of simple test code + _LT_COMPILER_BOILERPLATE + _LT_LINKER_BOILERPLATE + + # Allow CC to be a program name with arguments. + lt_save_CC="$CC" + lt_save_GCC=$GCC + lt_save_CFLAGS=$CFLAGS + CC=${FC-"f95"} + CFLAGS=$FCFLAGS + compiler=$CC + GCC=$ac_cv_fc_compiler_gnu + + _LT_TAGVAR(compiler, $1)=$CC + _LT_CC_BASENAME([$compiler]) + + if test -n "$compiler"; then + AC_MSG_CHECKING([if libtool supports shared libraries]) + AC_MSG_RESULT([$can_build_shared]) + + AC_MSG_CHECKING([whether to build shared libraries]) + test "$can_build_shared" = "no" && enable_shared=no + + # On AIX, shared libraries and static libraries use the same namespace, and + # are all built from PIC. + case $host_os in + aix3*) + test "$enable_shared" = yes && enable_static=no + if test -n "$RANLIB"; then + archive_cmds="$archive_cmds~\$RANLIB \$lib" + postinstall_cmds='$RANLIB $lib' + fi + ;; + aix[[4-9]]*) + if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then + test "$enable_shared" = yes && enable_static=no + fi + ;; + esac + AC_MSG_RESULT([$enable_shared]) + + AC_MSG_CHECKING([whether to build static libraries]) + # Make sure either enable_shared or enable_static is yes. + test "$enable_shared" = yes || enable_static=yes + AC_MSG_RESULT([$enable_static]) + + _LT_TAGVAR(GCC, $1)="$ac_cv_fc_compiler_gnu" + _LT_TAGVAR(LD, $1)="$LD" + + ## CAVEAT EMPTOR: + ## There is no encapsulation within the following macros, do not change + ## the running order or otherwise move them around unless you know exactly + ## what you are doing... + _LT_SYS_HIDDEN_LIBDEPS($1) + _LT_COMPILER_PIC($1) + _LT_COMPILER_C_O($1) + _LT_COMPILER_FILE_LOCKS($1) + _LT_LINKER_SHLIBS($1) + _LT_SYS_DYNAMIC_LINKER($1) + _LT_LINKER_HARDCODE_LIBPATH($1) + + _LT_CONFIG($1) + fi # test -n "$compiler" + + GCC=$lt_save_GCC + CC=$lt_save_CC + CFLAGS=$lt_save_CFLAGS +fi # test "$_lt_disable_FC" != yes + +AC_LANG_POP +])# _LT_LANG_FC_CONFIG + + +# _LT_LANG_GCJ_CONFIG([TAG]) +# -------------------------- +# Ensure that the configuration variables for the GNU Java Compiler compiler +# are suitably defined. These variables are subsequently used by _LT_CONFIG +# to write the compiler configuration to `libtool'. +m4_defun([_LT_LANG_GCJ_CONFIG], +[AC_REQUIRE([LT_PROG_GCJ])dnl +AC_LANG_SAVE + +# Source file extension for Java test sources. +ac_ext=java + +# Object file extension for compiled Java test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code="class foo {}" + +# Code to be used in simple link tests +lt_simple_link_test_code='public class conftest { public static void main(String[[]] argv) {}; }' + +# ltmain only uses $CC for tagged configurations so make sure $CC is set. +_LT_TAG_COMPILER + +# save warnings/boilerplate of simple test code +_LT_COMPILER_BOILERPLATE +_LT_LINKER_BOILERPLATE + +# Allow CC to be a program name with arguments. +lt_save_CC=$CC +lt_save_CFLAGS=$CFLAGS +lt_save_GCC=$GCC +GCC=yes +CC=${GCJ-"gcj"} +CFLAGS=$GCJFLAGS +compiler=$CC +_LT_TAGVAR(compiler, $1)=$CC +_LT_TAGVAR(LD, $1)="$LD" +_LT_CC_BASENAME([$compiler]) + +# GCJ did not exist at the time GCC didn't implicitly link libc in. +_LT_TAGVAR(archive_cmds_need_lc, $1)=no + +_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds +_LT_TAGVAR(reload_flag, $1)=$reload_flag +_LT_TAGVAR(reload_cmds, $1)=$reload_cmds + +## CAVEAT EMPTOR: +## There is no encapsulation within the following macros, do not change +## the running order or otherwise move them around unless you know exactly +## what you are doing... +if test -n "$compiler"; then + _LT_COMPILER_NO_RTTI($1) + _LT_COMPILER_PIC($1) + _LT_COMPILER_C_O($1) + _LT_COMPILER_FILE_LOCKS($1) + _LT_LINKER_SHLIBS($1) + _LT_LINKER_HARDCODE_LIBPATH($1) + + _LT_CONFIG($1) +fi + +AC_LANG_RESTORE + +GCC=$lt_save_GCC +CC=$lt_save_CC +CFLAGS=$lt_save_CFLAGS +])# _LT_LANG_GCJ_CONFIG + + +# _LT_LANG_GO_CONFIG([TAG]) +# -------------------------- +# Ensure that the configuration variables for the GNU Go compiler +# are suitably defined. These variables are subsequently used by _LT_CONFIG +# to write the compiler configuration to `libtool'. +m4_defun([_LT_LANG_GO_CONFIG], +[AC_REQUIRE([LT_PROG_GO])dnl +AC_LANG_SAVE + +# Source file extension for Go test sources. +ac_ext=go + +# Object file extension for compiled Go test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code="package main; func main() { }" + +# Code to be used in simple link tests +lt_simple_link_test_code='package main; func main() { }' + +# ltmain only uses $CC for tagged configurations so make sure $CC is set. +_LT_TAG_COMPILER + +# save warnings/boilerplate of simple test code +_LT_COMPILER_BOILERPLATE +_LT_LINKER_BOILERPLATE + +# Allow CC to be a program name with arguments. +lt_save_CC=$CC +lt_save_CFLAGS=$CFLAGS +lt_save_GCC=$GCC +GCC=yes +CC=${GOC-"gccgo"} +CFLAGS=$GOFLAGS +compiler=$CC +_LT_TAGVAR(compiler, $1)=$CC +_LT_TAGVAR(LD, $1)="$LD" +_LT_CC_BASENAME([$compiler]) + +# Go did not exist at the time GCC didn't implicitly link libc in. +_LT_TAGVAR(archive_cmds_need_lc, $1)=no + +_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds +_LT_TAGVAR(reload_flag, $1)=$reload_flag +_LT_TAGVAR(reload_cmds, $1)=$reload_cmds + +## CAVEAT EMPTOR: +## There is no encapsulation within the following macros, do not change +## the running order or otherwise move them around unless you know exactly +## what you are doing... +if test -n "$compiler"; then + _LT_COMPILER_NO_RTTI($1) + _LT_COMPILER_PIC($1) + _LT_COMPILER_C_O($1) + _LT_COMPILER_FILE_LOCKS($1) + _LT_LINKER_SHLIBS($1) + _LT_LINKER_HARDCODE_LIBPATH($1) + + _LT_CONFIG($1) +fi + +AC_LANG_RESTORE + +GCC=$lt_save_GCC +CC=$lt_save_CC +CFLAGS=$lt_save_CFLAGS +])# _LT_LANG_GO_CONFIG + + +# _LT_LANG_RC_CONFIG([TAG]) +# ------------------------- +# Ensure that the configuration variables for the Windows resource compiler +# are suitably defined. These variables are subsequently used by _LT_CONFIG +# to write the compiler configuration to `libtool'. +m4_defun([_LT_LANG_RC_CONFIG], +[AC_REQUIRE([LT_PROG_RC])dnl +AC_LANG_SAVE + +# Source file extension for RC test sources. +ac_ext=rc + +# Object file extension for compiled RC test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }' + +# Code to be used in simple link tests +lt_simple_link_test_code="$lt_simple_compile_test_code" + +# ltmain only uses $CC for tagged configurations so make sure $CC is set. +_LT_TAG_COMPILER + +# save warnings/boilerplate of simple test code +_LT_COMPILER_BOILERPLATE +_LT_LINKER_BOILERPLATE + +# Allow CC to be a program name with arguments. +lt_save_CC="$CC" +lt_save_CFLAGS=$CFLAGS +lt_save_GCC=$GCC +GCC= +CC=${RC-"windres"} +CFLAGS= +compiler=$CC +_LT_TAGVAR(compiler, $1)=$CC +_LT_CC_BASENAME([$compiler]) +_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes + +if test -n "$compiler"; then + : + _LT_CONFIG($1) +fi + +GCC=$lt_save_GCC +AC_LANG_RESTORE +CC=$lt_save_CC +CFLAGS=$lt_save_CFLAGS +])# _LT_LANG_RC_CONFIG + + +# LT_PROG_GCJ +# ----------- +AC_DEFUN([LT_PROG_GCJ], +[m4_ifdef([AC_PROG_GCJ], [AC_PROG_GCJ], + [m4_ifdef([A][M_PROG_GCJ], [A][M_PROG_GCJ], + [AC_CHECK_TOOL(GCJ, gcj,) + test "x${GCJFLAGS+set}" = xset || GCJFLAGS="-g -O2" + AC_SUBST(GCJFLAGS)])])[]dnl +]) + +# Old name: +AU_ALIAS([LT_AC_PROG_GCJ], [LT_PROG_GCJ]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([LT_AC_PROG_GCJ], []) + + +# LT_PROG_GO +# ---------- +AC_DEFUN([LT_PROG_GO], +[AC_CHECK_TOOL(GOC, gccgo,) +]) + + +# LT_PROG_RC +# ---------- +AC_DEFUN([LT_PROG_RC], +[AC_CHECK_TOOL(RC, windres,) +]) + +# Old name: +AU_ALIAS([LT_AC_PROG_RC], [LT_PROG_RC]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([LT_AC_PROG_RC], []) + + +# _LT_DECL_EGREP +# -------------- +# If we don't have a new enough Autoconf to choose the best grep +# available, choose the one first in the user's PATH. +m4_defun([_LT_DECL_EGREP], +[AC_REQUIRE([AC_PROG_EGREP])dnl +AC_REQUIRE([AC_PROG_FGREP])dnl +test -z "$GREP" && GREP=grep +_LT_DECL([], [GREP], [1], [A grep program that handles long lines]) +_LT_DECL([], [EGREP], [1], [An ERE matcher]) +_LT_DECL([], [FGREP], [1], [A literal string matcher]) +dnl Non-bleeding-edge autoconf doesn't subst GREP, so do it here too +AC_SUBST([GREP]) +]) + + +# _LT_DECL_OBJDUMP +# -------------- +# If we don't have a new enough Autoconf to choose the best objdump +# available, choose the one first in the user's PATH. +m4_defun([_LT_DECL_OBJDUMP], +[AC_CHECK_TOOL(OBJDUMP, objdump, false) +test -z "$OBJDUMP" && OBJDUMP=objdump +_LT_DECL([], [OBJDUMP], [1], [An object symbol dumper]) +AC_SUBST([OBJDUMP]) +]) + +# _LT_DECL_DLLTOOL +# ---------------- +# Ensure DLLTOOL variable is set. +m4_defun([_LT_DECL_DLLTOOL], +[AC_CHECK_TOOL(DLLTOOL, dlltool, false) +test -z "$DLLTOOL" && DLLTOOL=dlltool +_LT_DECL([], [DLLTOOL], [1], [DLL creation program]) +AC_SUBST([DLLTOOL]) +]) + +# _LT_DECL_SED +# ------------ +# Check for a fully-functional sed program, that truncates +# as few characters as possible. Prefer GNU sed if found. +m4_defun([_LT_DECL_SED], +[AC_PROG_SED +test -z "$SED" && SED=sed +Xsed="$SED -e 1s/^X//" +_LT_DECL([], [SED], [1], [A sed program that does not truncate output]) +_LT_DECL([], [Xsed], ["\$SED -e 1s/^X//"], + [Sed that helps us avoid accidentally triggering echo(1) options like -n]) +])# _LT_DECL_SED + +m4_ifndef([AC_PROG_SED], [ +############################################################ +# NOTE: This macro has been submitted for inclusion into # +# GNU Autoconf as AC_PROG_SED. When it is available in # +# a released version of Autoconf we should remove this # +# macro and use it instead. # +############################################################ + +m4_defun([AC_PROG_SED], +[AC_MSG_CHECKING([for a sed that does not truncate output]) +AC_CACHE_VAL(lt_cv_path_SED, +[# Loop through the user's path and test for sed and gsed. +# Then use that list of sed's as ones to test for truncation. +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for lt_ac_prog in sed gsed; do + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then + lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext" + fi + done + done +done +IFS=$as_save_IFS +lt_ac_max=0 +lt_ac_count=0 +# Add /usr/xpg4/bin/sed as it is typically found on Solaris +# along with /bin/sed that truncates output. +for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do + test ! -f $lt_ac_sed && continue + cat /dev/null > conftest.in + lt_ac_count=0 + echo $ECHO_N "0123456789$ECHO_C" >conftest.in + # Check for GNU sed and select it if it is found. + if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then + lt_cv_path_SED=$lt_ac_sed + break + fi + while true; do + cat conftest.in conftest.in >conftest.tmp + mv conftest.tmp conftest.in + cp conftest.in conftest.nl + echo >>conftest.nl + $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break + cmp -s conftest.out conftest.nl || break + # 10000 chars as input seems more than enough + test $lt_ac_count -gt 10 && break + lt_ac_count=`expr $lt_ac_count + 1` + if test $lt_ac_count -gt $lt_ac_max; then + lt_ac_max=$lt_ac_count + lt_cv_path_SED=$lt_ac_sed + fi + done +done +]) +SED=$lt_cv_path_SED +AC_SUBST([SED]) +AC_MSG_RESULT([$SED]) +])#AC_PROG_SED +])#m4_ifndef + +# Old name: +AU_ALIAS([LT_AC_PROG_SED], [AC_PROG_SED]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([LT_AC_PROG_SED], []) + + +# _LT_CHECK_SHELL_FEATURES +# ------------------------ +# Find out whether the shell is Bourne or XSI compatible, +# or has some other useful features. +m4_defun([_LT_CHECK_SHELL_FEATURES], +[AC_MSG_CHECKING([whether the shell understands some XSI constructs]) +# Try some XSI features +xsi_shell=no +( _lt_dummy="a/b/c" + test "${_lt_dummy##*/},${_lt_dummy%/*},${_lt_dummy#??}"${_lt_dummy%"$_lt_dummy"}, \ + = c,a/b,b/c, \ + && eval 'test $(( 1 + 1 )) -eq 2 \ + && test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \ + && xsi_shell=yes +AC_MSG_RESULT([$xsi_shell]) +_LT_CONFIG_LIBTOOL_INIT([xsi_shell='$xsi_shell']) + +AC_MSG_CHECKING([whether the shell understands "+="]) +lt_shell_append=no +( foo=bar; set foo baz; eval "$[1]+=\$[2]" && test "$foo" = barbaz ) \ + >/dev/null 2>&1 \ + && lt_shell_append=yes +AC_MSG_RESULT([$lt_shell_append]) +_LT_CONFIG_LIBTOOL_INIT([lt_shell_append='$lt_shell_append']) + +if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then + lt_unset=unset +else + lt_unset=false +fi +_LT_DECL([], [lt_unset], [0], [whether the shell understands "unset"])dnl + +# test EBCDIC or ASCII +case `echo X|tr X '\101'` in + A) # ASCII based system + # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr + lt_SP2NL='tr \040 \012' + lt_NL2SP='tr \015\012 \040\040' + ;; + *) # EBCDIC based system + lt_SP2NL='tr \100 \n' + lt_NL2SP='tr \r\n \100\100' + ;; +esac +_LT_DECL([SP2NL], [lt_SP2NL], [1], [turn spaces into newlines])dnl +_LT_DECL([NL2SP], [lt_NL2SP], [1], [turn newlines into spaces])dnl +])# _LT_CHECK_SHELL_FEATURES + + +# _LT_PROG_FUNCTION_REPLACE (FUNCNAME, REPLACEMENT-BODY) +# ------------------------------------------------------ +# In `$cfgfile', look for function FUNCNAME delimited by `^FUNCNAME ()$' and +# '^} FUNCNAME ', and replace its body with REPLACEMENT-BODY. +m4_defun([_LT_PROG_FUNCTION_REPLACE], +[dnl { +sed -e '/^$1 ()$/,/^} # $1 /c\ +$1 ()\ +{\ +m4_bpatsubsts([$2], [$], [\\], [^\([ ]\)], [\\\1]) +} # Extended-shell $1 implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: +]) + + +# _LT_PROG_REPLACE_SHELLFNS +# ------------------------- +# Replace existing portable implementations of several shell functions with +# equivalent extended shell implementations where those features are available.. +m4_defun([_LT_PROG_REPLACE_SHELLFNS], +[if test x"$xsi_shell" = xyes; then + _LT_PROG_FUNCTION_REPLACE([func_dirname], [dnl + case ${1} in + */*) func_dirname_result="${1%/*}${2}" ;; + * ) func_dirname_result="${3}" ;; + esac]) + + _LT_PROG_FUNCTION_REPLACE([func_basename], [dnl + func_basename_result="${1##*/}"]) + + _LT_PROG_FUNCTION_REPLACE([func_dirname_and_basename], [dnl + case ${1} in + */*) func_dirname_result="${1%/*}${2}" ;; + * ) func_dirname_result="${3}" ;; + esac + func_basename_result="${1##*/}"]) + + _LT_PROG_FUNCTION_REPLACE([func_stripname], [dnl + # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are + # positional parameters, so assign one to ordinary parameter first. + func_stripname_result=${3} + func_stripname_result=${func_stripname_result#"${1}"} + func_stripname_result=${func_stripname_result%"${2}"}]) + + _LT_PROG_FUNCTION_REPLACE([func_split_long_opt], [dnl + func_split_long_opt_name=${1%%=*} + func_split_long_opt_arg=${1#*=}]) + + _LT_PROG_FUNCTION_REPLACE([func_split_short_opt], [dnl + func_split_short_opt_arg=${1#??} + func_split_short_opt_name=${1%"$func_split_short_opt_arg"}]) + + _LT_PROG_FUNCTION_REPLACE([func_lo2o], [dnl + case ${1} in + *.lo) func_lo2o_result=${1%.lo}.${objext} ;; + *) func_lo2o_result=${1} ;; + esac]) + + _LT_PROG_FUNCTION_REPLACE([func_xform], [ func_xform_result=${1%.*}.lo]) + + _LT_PROG_FUNCTION_REPLACE([func_arith], [ func_arith_result=$(( $[*] ))]) + + _LT_PROG_FUNCTION_REPLACE([func_len], [ func_len_result=${#1}]) +fi + +if test x"$lt_shell_append" = xyes; then + _LT_PROG_FUNCTION_REPLACE([func_append], [ eval "${1}+=\\${2}"]) + + _LT_PROG_FUNCTION_REPLACE([func_append_quoted], [dnl + func_quote_for_eval "${2}" +dnl m4 expansion turns \\\\ into \\, and then the shell eval turns that into \ + eval "${1}+=\\\\ \\$func_quote_for_eval_result"]) + + # Save a `func_append' function call where possible by direct use of '+=' + sed -e 's%func_append \([[a-zA-Z_]]\{1,\}\) "%\1+="%g' $cfgfile > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") + test 0 -eq $? || _lt_function_replace_fail=: +else + # Save a `func_append' function call even when '+=' is not available + sed -e 's%func_append \([[a-zA-Z_]]\{1,\}\) "%\1="$\1%g' $cfgfile > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") + test 0 -eq $? || _lt_function_replace_fail=: +fi + +if test x"$_lt_function_replace_fail" = x":"; then + AC_MSG_WARN([Unable to substitute extended shell functions in $ofile]) +fi +]) + +# _LT_PATH_CONVERSION_FUNCTIONS +# ----------------------------- +# Determine which file name conversion functions should be used by +# func_to_host_file (and, implicitly, by func_to_host_path). These are needed +# for certain cross-compile configurations and native mingw. +m4_defun([_LT_PATH_CONVERSION_FUNCTIONS], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +AC_REQUIRE([AC_CANONICAL_BUILD])dnl +AC_MSG_CHECKING([how to convert $build file names to $host format]) +AC_CACHE_VAL(lt_cv_to_host_file_cmd, +[case $host in + *-*-mingw* ) + case $build in + *-*-mingw* ) # actually msys + lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32 + ;; + *-*-cygwin* ) + lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32 + ;; + * ) # otherwise, assume *nix + lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32 + ;; + esac + ;; + *-*-cygwin* ) + case $build in + *-*-mingw* ) # actually msys + lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin + ;; + *-*-cygwin* ) + lt_cv_to_host_file_cmd=func_convert_file_noop + ;; + * ) # otherwise, assume *nix + lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin + ;; + esac + ;; + * ) # unhandled hosts (and "normal" native builds) + lt_cv_to_host_file_cmd=func_convert_file_noop + ;; +esac +]) +to_host_file_cmd=$lt_cv_to_host_file_cmd +AC_MSG_RESULT([$lt_cv_to_host_file_cmd]) +_LT_DECL([to_host_file_cmd], [lt_cv_to_host_file_cmd], + [0], [convert $build file names to $host format])dnl + +AC_MSG_CHECKING([how to convert $build file names to toolchain format]) +AC_CACHE_VAL(lt_cv_to_tool_file_cmd, +[#assume ordinary cross tools, or native build. +lt_cv_to_tool_file_cmd=func_convert_file_noop +case $host in + *-*-mingw* ) + case $build in + *-*-mingw* ) # actually msys + lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32 + ;; + esac + ;; +esac +]) +to_tool_file_cmd=$lt_cv_to_tool_file_cmd +AC_MSG_RESULT([$lt_cv_to_tool_file_cmd]) +_LT_DECL([to_tool_file_cmd], [lt_cv_to_tool_file_cmd], + [0], [convert $build files to toolchain format])dnl +])# _LT_PATH_CONVERSION_FUNCTIONS diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/m4/ltoptions.m4 b/native_client/ctcdecode/third_party/openfst-1.6.7/m4/ltoptions.m4 new file mode 100644 index 0000000000..5d9acd8e23 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/m4/ltoptions.m4 @@ -0,0 +1,384 @@ +# Helper functions for option handling. -*- Autoconf -*- +# +# Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation, +# Inc. +# Written by Gary V. Vaughan, 2004 +# +# This file is free software; the Free Software Foundation gives +# unlimited permission to copy and/or distribute it, with or without +# modifications, as long as this notice is preserved. + +# serial 7 ltoptions.m4 + +# This is to help aclocal find these macros, as it can't see m4_define. +AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])]) + + +# _LT_MANGLE_OPTION(MACRO-NAME, OPTION-NAME) +# ------------------------------------------ +m4_define([_LT_MANGLE_OPTION], +[[_LT_OPTION_]m4_bpatsubst($1__$2, [[^a-zA-Z0-9_]], [_])]) + + +# _LT_SET_OPTION(MACRO-NAME, OPTION-NAME) +# --------------------------------------- +# Set option OPTION-NAME for macro MACRO-NAME, and if there is a +# matching handler defined, dispatch to it. Other OPTION-NAMEs are +# saved as a flag. +m4_define([_LT_SET_OPTION], +[m4_define(_LT_MANGLE_OPTION([$1], [$2]))dnl +m4_ifdef(_LT_MANGLE_DEFUN([$1], [$2]), + _LT_MANGLE_DEFUN([$1], [$2]), + [m4_warning([Unknown $1 option `$2'])])[]dnl +]) + + +# _LT_IF_OPTION(MACRO-NAME, OPTION-NAME, IF-SET, [IF-NOT-SET]) +# ------------------------------------------------------------ +# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise. +m4_define([_LT_IF_OPTION], +[m4_ifdef(_LT_MANGLE_OPTION([$1], [$2]), [$3], [$4])]) + + +# _LT_UNLESS_OPTIONS(MACRO-NAME, OPTION-LIST, IF-NOT-SET) +# ------------------------------------------------------- +# Execute IF-NOT-SET unless all options in OPTION-LIST for MACRO-NAME +# are set. +m4_define([_LT_UNLESS_OPTIONS], +[m4_foreach([_LT_Option], m4_split(m4_normalize([$2])), + [m4_ifdef(_LT_MANGLE_OPTION([$1], _LT_Option), + [m4_define([$0_found])])])[]dnl +m4_ifdef([$0_found], [m4_undefine([$0_found])], [$3 +])[]dnl +]) + + +# _LT_SET_OPTIONS(MACRO-NAME, OPTION-LIST) +# ---------------------------------------- +# OPTION-LIST is a space-separated list of Libtool options associated +# with MACRO-NAME. If any OPTION has a matching handler declared with +# LT_OPTION_DEFINE, dispatch to that macro; otherwise complain about +# the unknown option and exit. +m4_defun([_LT_SET_OPTIONS], +[# Set options +m4_foreach([_LT_Option], m4_split(m4_normalize([$2])), + [_LT_SET_OPTION([$1], _LT_Option)]) + +m4_if([$1],[LT_INIT],[ + dnl + dnl Simply set some default values (i.e off) if boolean options were not + dnl specified: + _LT_UNLESS_OPTIONS([LT_INIT], [dlopen], [enable_dlopen=no + ]) + _LT_UNLESS_OPTIONS([LT_INIT], [win32-dll], [enable_win32_dll=no + ]) + dnl + dnl If no reference was made to various pairs of opposing options, then + dnl we run the default mode handler for the pair. For example, if neither + dnl `shared' nor `disable-shared' was passed, we enable building of shared + dnl archives by default: + _LT_UNLESS_OPTIONS([LT_INIT], [shared disable-shared], [_LT_ENABLE_SHARED]) + _LT_UNLESS_OPTIONS([LT_INIT], [static disable-static], [_LT_ENABLE_STATIC]) + _LT_UNLESS_OPTIONS([LT_INIT], [pic-only no-pic], [_LT_WITH_PIC]) + _LT_UNLESS_OPTIONS([LT_INIT], [fast-install disable-fast-install], + [_LT_ENABLE_FAST_INSTALL]) + ]) +])# _LT_SET_OPTIONS + + +## --------------------------------- ## +## Macros to handle LT_INIT options. ## +## --------------------------------- ## + +# _LT_MANGLE_DEFUN(MACRO-NAME, OPTION-NAME) +# ----------------------------------------- +m4_define([_LT_MANGLE_DEFUN], +[[_LT_OPTION_DEFUN_]m4_bpatsubst(m4_toupper([$1__$2]), [[^A-Z0-9_]], [_])]) + + +# LT_OPTION_DEFINE(MACRO-NAME, OPTION-NAME, CODE) +# ----------------------------------------------- +m4_define([LT_OPTION_DEFINE], +[m4_define(_LT_MANGLE_DEFUN([$1], [$2]), [$3])[]dnl +])# LT_OPTION_DEFINE + + +# dlopen +# ------ +LT_OPTION_DEFINE([LT_INIT], [dlopen], [enable_dlopen=yes +]) + +AU_DEFUN([AC_LIBTOOL_DLOPEN], +[_LT_SET_OPTION([LT_INIT], [dlopen]) +AC_DIAGNOSE([obsolete], +[$0: Remove this warning and the call to _LT_SET_OPTION when you +put the `dlopen' option into LT_INIT's first parameter.]) +]) + +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_DLOPEN], []) + + +# win32-dll +# --------- +# Declare package support for building win32 dll's. +LT_OPTION_DEFINE([LT_INIT], [win32-dll], +[enable_win32_dll=yes + +case $host in +*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc*) + AC_CHECK_TOOL(AS, as, false) + AC_CHECK_TOOL(DLLTOOL, dlltool, false) + AC_CHECK_TOOL(OBJDUMP, objdump, false) + ;; +esac + +test -z "$AS" && AS=as +_LT_DECL([], [AS], [1], [Assembler program])dnl + +test -z "$DLLTOOL" && DLLTOOL=dlltool +_LT_DECL([], [DLLTOOL], [1], [DLL creation program])dnl + +test -z "$OBJDUMP" && OBJDUMP=objdump +_LT_DECL([], [OBJDUMP], [1], [Object dumper program])dnl +])# win32-dll + +AU_DEFUN([AC_LIBTOOL_WIN32_DLL], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +_LT_SET_OPTION([LT_INIT], [win32-dll]) +AC_DIAGNOSE([obsolete], +[$0: Remove this warning and the call to _LT_SET_OPTION when you +put the `win32-dll' option into LT_INIT's first parameter.]) +]) + +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_WIN32_DLL], []) + + +# _LT_ENABLE_SHARED([DEFAULT]) +# ---------------------------- +# implement the --enable-shared flag, and supports the `shared' and +# `disable-shared' LT_INIT options. +# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. +m4_define([_LT_ENABLE_SHARED], +[m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl +AC_ARG_ENABLE([shared], + [AS_HELP_STRING([--enable-shared@<:@=PKGS@:>@], + [build shared libraries @<:@default=]_LT_ENABLE_SHARED_DEFAULT[@:>@])], + [p=${PACKAGE-default} + case $enableval in + yes) enable_shared=yes ;; + no) enable_shared=no ;; + *) + enable_shared=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_shared=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac], + [enable_shared=]_LT_ENABLE_SHARED_DEFAULT) + + _LT_DECL([build_libtool_libs], [enable_shared], [0], + [Whether or not to build shared libraries]) +])# _LT_ENABLE_SHARED + +LT_OPTION_DEFINE([LT_INIT], [shared], [_LT_ENABLE_SHARED([yes])]) +LT_OPTION_DEFINE([LT_INIT], [disable-shared], [_LT_ENABLE_SHARED([no])]) + +# Old names: +AC_DEFUN([AC_ENABLE_SHARED], +[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[shared]) +]) + +AC_DEFUN([AC_DISABLE_SHARED], +[_LT_SET_OPTION([LT_INIT], [disable-shared]) +]) + +AU_DEFUN([AM_ENABLE_SHARED], [AC_ENABLE_SHARED($@)]) +AU_DEFUN([AM_DISABLE_SHARED], [AC_DISABLE_SHARED($@)]) + +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AM_ENABLE_SHARED], []) +dnl AC_DEFUN([AM_DISABLE_SHARED], []) + + + +# _LT_ENABLE_STATIC([DEFAULT]) +# ---------------------------- +# implement the --enable-static flag, and support the `static' and +# `disable-static' LT_INIT options. +# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. +m4_define([_LT_ENABLE_STATIC], +[m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl +AC_ARG_ENABLE([static], + [AS_HELP_STRING([--enable-static@<:@=PKGS@:>@], + [build static libraries @<:@default=]_LT_ENABLE_STATIC_DEFAULT[@:>@])], + [p=${PACKAGE-default} + case $enableval in + yes) enable_static=yes ;; + no) enable_static=no ;; + *) + enable_static=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_static=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac], + [enable_static=]_LT_ENABLE_STATIC_DEFAULT) + + _LT_DECL([build_old_libs], [enable_static], [0], + [Whether or not to build static libraries]) +])# _LT_ENABLE_STATIC + +LT_OPTION_DEFINE([LT_INIT], [static], [_LT_ENABLE_STATIC([yes])]) +LT_OPTION_DEFINE([LT_INIT], [disable-static], [_LT_ENABLE_STATIC([no])]) + +# Old names: +AC_DEFUN([AC_ENABLE_STATIC], +[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[static]) +]) + +AC_DEFUN([AC_DISABLE_STATIC], +[_LT_SET_OPTION([LT_INIT], [disable-static]) +]) + +AU_DEFUN([AM_ENABLE_STATIC], [AC_ENABLE_STATIC($@)]) +AU_DEFUN([AM_DISABLE_STATIC], [AC_DISABLE_STATIC($@)]) + +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AM_ENABLE_STATIC], []) +dnl AC_DEFUN([AM_DISABLE_STATIC], []) + + + +# _LT_ENABLE_FAST_INSTALL([DEFAULT]) +# ---------------------------------- +# implement the --enable-fast-install flag, and support the `fast-install' +# and `disable-fast-install' LT_INIT options. +# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. +m4_define([_LT_ENABLE_FAST_INSTALL], +[m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl +AC_ARG_ENABLE([fast-install], + [AS_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@], + [optimize for fast installation @<:@default=]_LT_ENABLE_FAST_INSTALL_DEFAULT[@:>@])], + [p=${PACKAGE-default} + case $enableval in + yes) enable_fast_install=yes ;; + no) enable_fast_install=no ;; + *) + enable_fast_install=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_fast_install=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac], + [enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT) + +_LT_DECL([fast_install], [enable_fast_install], [0], + [Whether or not to optimize for fast installation])dnl +])# _LT_ENABLE_FAST_INSTALL + +LT_OPTION_DEFINE([LT_INIT], [fast-install], [_LT_ENABLE_FAST_INSTALL([yes])]) +LT_OPTION_DEFINE([LT_INIT], [disable-fast-install], [_LT_ENABLE_FAST_INSTALL([no])]) + +# Old names: +AU_DEFUN([AC_ENABLE_FAST_INSTALL], +[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install]) +AC_DIAGNOSE([obsolete], +[$0: Remove this warning and the call to _LT_SET_OPTION when you put +the `fast-install' option into LT_INIT's first parameter.]) +]) + +AU_DEFUN([AC_DISABLE_FAST_INSTALL], +[_LT_SET_OPTION([LT_INIT], [disable-fast-install]) +AC_DIAGNOSE([obsolete], +[$0: Remove this warning and the call to _LT_SET_OPTION when you put +the `disable-fast-install' option into LT_INIT's first parameter.]) +]) + +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_ENABLE_FAST_INSTALL], []) +dnl AC_DEFUN([AM_DISABLE_FAST_INSTALL], []) + + +# _LT_WITH_PIC([MODE]) +# -------------------- +# implement the --with-pic flag, and support the `pic-only' and `no-pic' +# LT_INIT options. +# MODE is either `yes' or `no'. If omitted, it defaults to `both'. +m4_define([_LT_WITH_PIC], +[AC_ARG_WITH([pic], + [AS_HELP_STRING([--with-pic@<:@=PKGS@:>@], + [try to use only PIC/non-PIC objects @<:@default=use both@:>@])], + [lt_p=${PACKAGE-default} + case $withval in + yes|no) pic_mode=$withval ;; + *) + pic_mode=default + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for lt_pkg in $withval; do + IFS="$lt_save_ifs" + if test "X$lt_pkg" = "X$lt_p"; then + pic_mode=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac], + [pic_mode=default]) + +test -z "$pic_mode" && pic_mode=m4_default([$1], [default]) + +_LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl +])# _LT_WITH_PIC + +LT_OPTION_DEFINE([LT_INIT], [pic-only], [_LT_WITH_PIC([yes])]) +LT_OPTION_DEFINE([LT_INIT], [no-pic], [_LT_WITH_PIC([no])]) + +# Old name: +AU_DEFUN([AC_LIBTOOL_PICMODE], +[_LT_SET_OPTION([LT_INIT], [pic-only]) +AC_DIAGNOSE([obsolete], +[$0: Remove this warning and the call to _LT_SET_OPTION when you +put the `pic-only' option into LT_INIT's first parameter.]) +]) + +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_PICMODE], []) + +## ----------------- ## +## LTDL_INIT Options ## +## ----------------- ## + +m4_define([_LTDL_MODE], []) +LT_OPTION_DEFINE([LTDL_INIT], [nonrecursive], + [m4_define([_LTDL_MODE], [nonrecursive])]) +LT_OPTION_DEFINE([LTDL_INIT], [recursive], + [m4_define([_LTDL_MODE], [recursive])]) +LT_OPTION_DEFINE([LTDL_INIT], [subproject], + [m4_define([_LTDL_MODE], [subproject])]) + +m4_define([_LTDL_TYPE], []) +LT_OPTION_DEFINE([LTDL_INIT], [installable], + [m4_define([_LTDL_TYPE], [installable])]) +LT_OPTION_DEFINE([LTDL_INIT], [convenience], + [m4_define([_LTDL_TYPE], [convenience])]) diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/m4/ltsugar.m4 b/native_client/ctcdecode/third_party/openfst-1.6.7/m4/ltsugar.m4 new file mode 100644 index 0000000000..9000a057d3 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/m4/ltsugar.m4 @@ -0,0 +1,123 @@ +# ltsugar.m4 -- libtool m4 base layer. -*-Autoconf-*- +# +# Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc. +# Written by Gary V. Vaughan, 2004 +# +# This file is free software; the Free Software Foundation gives +# unlimited permission to copy and/or distribute it, with or without +# modifications, as long as this notice is preserved. + +# serial 6 ltsugar.m4 + +# This is to help aclocal find these macros, as it can't see m4_define. +AC_DEFUN([LTSUGAR_VERSION], [m4_if([0.1])]) + + +# lt_join(SEP, ARG1, [ARG2...]) +# ----------------------------- +# Produce ARG1SEPARG2...SEPARGn, omitting [] arguments and their +# associated separator. +# Needed until we can rely on m4_join from Autoconf 2.62, since all earlier +# versions in m4sugar had bugs. +m4_define([lt_join], +[m4_if([$#], [1], [], + [$#], [2], [[$2]], + [m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift(m4_shift($@)))])]) +m4_define([_lt_join], +[m4_if([$#$2], [2], [], + [m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift(m4_shift($@)))])]) + + +# lt_car(LIST) +# lt_cdr(LIST) +# ------------ +# Manipulate m4 lists. +# These macros are necessary as long as will still need to support +# Autoconf-2.59 which quotes differently. +m4_define([lt_car], [[$1]]) +m4_define([lt_cdr], +[m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])], + [$#], 1, [], + [m4_dquote(m4_shift($@))])]) +m4_define([lt_unquote], $1) + + +# lt_append(MACRO-NAME, STRING, [SEPARATOR]) +# ------------------------------------------ +# Redefine MACRO-NAME to hold its former content plus `SEPARATOR'`STRING'. +# Note that neither SEPARATOR nor STRING are expanded; they are appended +# to MACRO-NAME as is (leaving the expansion for when MACRO-NAME is invoked). +# No SEPARATOR is output if MACRO-NAME was previously undefined (different +# than defined and empty). +# +# This macro is needed until we can rely on Autoconf 2.62, since earlier +# versions of m4sugar mistakenly expanded SEPARATOR but not STRING. +m4_define([lt_append], +[m4_define([$1], + m4_ifdef([$1], [m4_defn([$1])[$3]])[$2])]) + + + +# lt_combine(SEP, PREFIX-LIST, INFIX, SUFFIX1, [SUFFIX2...]) +# ---------------------------------------------------------- +# Produce a SEP delimited list of all paired combinations of elements of +# PREFIX-LIST with SUFFIX1 through SUFFIXn. Each element of the list +# has the form PREFIXmINFIXSUFFIXn. +# Needed until we can rely on m4_combine added in Autoconf 2.62. +m4_define([lt_combine], +[m4_if(m4_eval([$# > 3]), [1], + [m4_pushdef([_Lt_sep], [m4_define([_Lt_sep], m4_defn([lt_car]))])]]dnl +[[m4_foreach([_Lt_prefix], [$2], + [m4_foreach([_Lt_suffix], + ]m4_dquote(m4_dquote(m4_shift(m4_shift(m4_shift($@)))))[, + [_Lt_sep([$1])[]m4_defn([_Lt_prefix])[$3]m4_defn([_Lt_suffix])])])])]) + + +# lt_if_append_uniq(MACRO-NAME, VARNAME, [SEPARATOR], [UNIQ], [NOT-UNIQ]) +# ----------------------------------------------------------------------- +# Iff MACRO-NAME does not yet contain VARNAME, then append it (delimited +# by SEPARATOR if supplied) and expand UNIQ, else NOT-UNIQ. +m4_define([lt_if_append_uniq], +[m4_ifdef([$1], + [m4_if(m4_index([$3]m4_defn([$1])[$3], [$3$2$3]), [-1], + [lt_append([$1], [$2], [$3])$4], + [$5])], + [lt_append([$1], [$2], [$3])$4])]) + + +# lt_dict_add(DICT, KEY, VALUE) +# ----------------------------- +m4_define([lt_dict_add], +[m4_define([$1($2)], [$3])]) + + +# lt_dict_add_subkey(DICT, KEY, SUBKEY, VALUE) +# -------------------------------------------- +m4_define([lt_dict_add_subkey], +[m4_define([$1($2:$3)], [$4])]) + + +# lt_dict_fetch(DICT, KEY, [SUBKEY]) +# ---------------------------------- +m4_define([lt_dict_fetch], +[m4_ifval([$3], + m4_ifdef([$1($2:$3)], [m4_defn([$1($2:$3)])]), + m4_ifdef([$1($2)], [m4_defn([$1($2)])]))]) + + +# lt_if_dict_fetch(DICT, KEY, [SUBKEY], VALUE, IF-TRUE, [IF-FALSE]) +# ----------------------------------------------------------------- +m4_define([lt_if_dict_fetch], +[m4_if(lt_dict_fetch([$1], [$2], [$3]), [$4], + [$5], + [$6])]) + + +# lt_dict_filter(DICT, [SUBKEY], VALUE, [SEPARATOR], KEY, [...]) +# -------------------------------------------------------------- +m4_define([lt_dict_filter], +[m4_if([$5], [], [], + [lt_join(m4_quote(m4_default([$4], [[, ]])), + lt_unquote(m4_split(m4_normalize(m4_foreach(_Lt_key, lt_car([m4_shiftn(4, $@)]), + [lt_if_dict_fetch([$1], _Lt_key, [$2], [$3], [_Lt_key ])])))))])[]dnl +]) diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/m4/ltversion.m4 b/native_client/ctcdecode/third_party/openfst-1.6.7/m4/ltversion.m4 new file mode 100644 index 0000000000..07a8602d48 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/m4/ltversion.m4 @@ -0,0 +1,23 @@ +# ltversion.m4 -- version numbers -*- Autoconf -*- +# +# Copyright (C) 2004 Free Software Foundation, Inc. +# Written by Scott James Remnant, 2004 +# +# This file is free software; the Free Software Foundation gives +# unlimited permission to copy and/or distribute it, with or without +# modifications, as long as this notice is preserved. + +# @configure_input@ + +# serial 3337 ltversion.m4 +# This file is part of GNU Libtool + +m4_define([LT_PACKAGE_VERSION], [2.4.2]) +m4_define([LT_PACKAGE_REVISION], [1.3337]) + +AC_DEFUN([LTVERSION_VERSION], +[macro_version='2.4.2' +macro_revision='1.3337' +_LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?]) +_LT_DECL(, macro_revision, 0) +]) diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/m4/lt~obsolete.m4 b/native_client/ctcdecode/third_party/openfst-1.6.7/m4/lt~obsolete.m4 new file mode 100644 index 0000000000..c573da90c5 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/m4/lt~obsolete.m4 @@ -0,0 +1,98 @@ +# lt~obsolete.m4 -- aclocal satisfying obsolete definitions. -*-Autoconf-*- +# +# Copyright (C) 2004, 2005, 2007, 2009 Free Software Foundation, Inc. +# Written by Scott James Remnant, 2004. +# +# This file is free software; the Free Software Foundation gives +# unlimited permission to copy and/or distribute it, with or without +# modifications, as long as this notice is preserved. + +# serial 5 lt~obsolete.m4 + +# These exist entirely to fool aclocal when bootstrapping libtool. +# +# In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN) +# which have later been changed to m4_define as they aren't part of the +# exported API, or moved to Autoconf or Automake where they belong. +# +# The trouble is, aclocal is a bit thick. It'll see the old AC_DEFUN +# in /usr/share/aclocal/libtool.m4 and remember it, then when it sees us +# using a macro with the same name in our local m4/libtool.m4 it'll +# pull the old libtool.m4 in (it doesn't see our shiny new m4_define +# and doesn't know about Autoconf macros at all.) +# +# So we provide this file, which has a silly filename so it's always +# included after everything else. This provides aclocal with the +# AC_DEFUNs it wants, but when m4 processes it, it doesn't do anything +# because those macros already exist, or will be overwritten later. +# We use AC_DEFUN over AU_DEFUN for compatibility with aclocal-1.6. +# +# Anytime we withdraw an AC_DEFUN or AU_DEFUN, remember to add it here. +# Yes, that means every name once taken will need to remain here until +# we give up compatibility with versions before 1.7, at which point +# we need to keep only those names which we still refer to. + +# This is to help aclocal find these macros, as it can't see m4_define. +AC_DEFUN([LTOBSOLETE_VERSION], [m4_if([1])]) + +m4_ifndef([AC_LIBTOOL_LINKER_OPTION], [AC_DEFUN([AC_LIBTOOL_LINKER_OPTION])]) +m4_ifndef([AC_PROG_EGREP], [AC_DEFUN([AC_PROG_EGREP])]) +m4_ifndef([_LT_AC_PROG_ECHO_BACKSLASH], [AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH])]) +m4_ifndef([_LT_AC_SHELL_INIT], [AC_DEFUN([_LT_AC_SHELL_INIT])]) +m4_ifndef([_LT_AC_SYS_LIBPATH_AIX], [AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX])]) +m4_ifndef([_LT_PROG_LTMAIN], [AC_DEFUN([_LT_PROG_LTMAIN])]) +m4_ifndef([_LT_AC_TAGVAR], [AC_DEFUN([_LT_AC_TAGVAR])]) +m4_ifndef([AC_LTDL_ENABLE_INSTALL], [AC_DEFUN([AC_LTDL_ENABLE_INSTALL])]) +m4_ifndef([AC_LTDL_PREOPEN], [AC_DEFUN([AC_LTDL_PREOPEN])]) +m4_ifndef([_LT_AC_SYS_COMPILER], [AC_DEFUN([_LT_AC_SYS_COMPILER])]) +m4_ifndef([_LT_AC_LOCK], [AC_DEFUN([_LT_AC_LOCK])]) +m4_ifndef([AC_LIBTOOL_SYS_OLD_ARCHIVE], [AC_DEFUN([AC_LIBTOOL_SYS_OLD_ARCHIVE])]) +m4_ifndef([_LT_AC_TRY_DLOPEN_SELF], [AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF])]) +m4_ifndef([AC_LIBTOOL_PROG_CC_C_O], [AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O])]) +m4_ifndef([AC_LIBTOOL_SYS_HARD_LINK_LOCKS], [AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS])]) +m4_ifndef([AC_LIBTOOL_OBJDIR], [AC_DEFUN([AC_LIBTOOL_OBJDIR])]) +m4_ifndef([AC_LTDL_OBJDIR], [AC_DEFUN([AC_LTDL_OBJDIR])]) +m4_ifndef([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH], [AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH])]) +m4_ifndef([AC_LIBTOOL_SYS_LIB_STRIP], [AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP])]) +m4_ifndef([AC_PATH_MAGIC], [AC_DEFUN([AC_PATH_MAGIC])]) +m4_ifndef([AC_PROG_LD_GNU], [AC_DEFUN([AC_PROG_LD_GNU])]) +m4_ifndef([AC_PROG_LD_RELOAD_FLAG], [AC_DEFUN([AC_PROG_LD_RELOAD_FLAG])]) +m4_ifndef([AC_DEPLIBS_CHECK_METHOD], [AC_DEFUN([AC_DEPLIBS_CHECK_METHOD])]) +m4_ifndef([AC_LIBTOOL_PROG_COMPILER_NO_RTTI], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI])]) +m4_ifndef([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE], [AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])]) +m4_ifndef([AC_LIBTOOL_PROG_COMPILER_PIC], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC])]) +m4_ifndef([AC_LIBTOOL_PROG_LD_SHLIBS], [AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS])]) +m4_ifndef([AC_LIBTOOL_POSTDEP_PREDEP], [AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP])]) +m4_ifndef([LT_AC_PROG_EGREP], [AC_DEFUN([LT_AC_PROG_EGREP])]) +m4_ifndef([LT_AC_PROG_SED], [AC_DEFUN([LT_AC_PROG_SED])]) +m4_ifndef([_LT_CC_BASENAME], [AC_DEFUN([_LT_CC_BASENAME])]) +m4_ifndef([_LT_COMPILER_BOILERPLATE], [AC_DEFUN([_LT_COMPILER_BOILERPLATE])]) +m4_ifndef([_LT_LINKER_BOILERPLATE], [AC_DEFUN([_LT_LINKER_BOILERPLATE])]) +m4_ifndef([_AC_PROG_LIBTOOL], [AC_DEFUN([_AC_PROG_LIBTOOL])]) +m4_ifndef([AC_LIBTOOL_SETUP], [AC_DEFUN([AC_LIBTOOL_SETUP])]) +m4_ifndef([_LT_AC_CHECK_DLFCN], [AC_DEFUN([_LT_AC_CHECK_DLFCN])]) +m4_ifndef([AC_LIBTOOL_SYS_DYNAMIC_LINKER], [AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER])]) +m4_ifndef([_LT_AC_TAGCONFIG], [AC_DEFUN([_LT_AC_TAGCONFIG])]) +m4_ifndef([AC_DISABLE_FAST_INSTALL], [AC_DEFUN([AC_DISABLE_FAST_INSTALL])]) +m4_ifndef([_LT_AC_LANG_CXX], [AC_DEFUN([_LT_AC_LANG_CXX])]) +m4_ifndef([_LT_AC_LANG_F77], [AC_DEFUN([_LT_AC_LANG_F77])]) +m4_ifndef([_LT_AC_LANG_GCJ], [AC_DEFUN([_LT_AC_LANG_GCJ])]) +m4_ifndef([AC_LIBTOOL_LANG_C_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_C_CONFIG])]) +m4_ifndef([_LT_AC_LANG_C_CONFIG], [AC_DEFUN([_LT_AC_LANG_C_CONFIG])]) +m4_ifndef([AC_LIBTOOL_LANG_CXX_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_CXX_CONFIG])]) +m4_ifndef([_LT_AC_LANG_CXX_CONFIG], [AC_DEFUN([_LT_AC_LANG_CXX_CONFIG])]) +m4_ifndef([AC_LIBTOOL_LANG_F77_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_F77_CONFIG])]) +m4_ifndef([_LT_AC_LANG_F77_CONFIG], [AC_DEFUN([_LT_AC_LANG_F77_CONFIG])]) +m4_ifndef([AC_LIBTOOL_LANG_GCJ_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_GCJ_CONFIG])]) +m4_ifndef([_LT_AC_LANG_GCJ_CONFIG], [AC_DEFUN([_LT_AC_LANG_GCJ_CONFIG])]) +m4_ifndef([AC_LIBTOOL_LANG_RC_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_RC_CONFIG])]) +m4_ifndef([_LT_AC_LANG_RC_CONFIG], [AC_DEFUN([_LT_AC_LANG_RC_CONFIG])]) +m4_ifndef([AC_LIBTOOL_CONFIG], [AC_DEFUN([AC_LIBTOOL_CONFIG])]) +m4_ifndef([_LT_AC_FILE_LTDLL_C], [AC_DEFUN([_LT_AC_FILE_LTDLL_C])]) +m4_ifndef([_LT_REQUIRED_DARWIN_CHECKS], [AC_DEFUN([_LT_REQUIRED_DARWIN_CHECKS])]) +m4_ifndef([_LT_AC_PROG_CXXCPP], [AC_DEFUN([_LT_AC_PROG_CXXCPP])]) +m4_ifndef([_LT_PREPARE_SED_QUOTE_VARS], [AC_DEFUN([_LT_PREPARE_SED_QUOTE_VARS])]) +m4_ifndef([_LT_PROG_ECHO_BACKSLASH], [AC_DEFUN([_LT_PROG_ECHO_BACKSLASH])]) +m4_ifndef([_LT_PROG_F77], [AC_DEFUN([_LT_PROG_F77])]) +m4_ifndef([_LT_PROG_FC], [AC_DEFUN([_LT_PROG_FC])]) +m4_ifndef([_LT_PROG_CXX], [AC_DEFUN([_LT_PROG_CXX])]) diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/missing b/native_client/ctcdecode/third_party/openfst-1.6.7/missing new file mode 100755 index 0000000000..db98974ff5 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/missing @@ -0,0 +1,215 @@ +#! /bin/sh +# Common wrapper for a few potentially missing GNU programs. + +scriptversion=2013-10-28.13; # UTC + +# Copyright (C) 1996-2013 Free Software Foundation, Inc. +# Originally written by Fran,cois Pinard , 1996. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, or (at your option) +# any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +if test $# -eq 0; then + echo 1>&2 "Try '$0 --help' for more information" + exit 1 +fi + +case $1 in + + --is-lightweight) + # Used by our autoconf macros to check whether the available missing + # script is modern enough. + exit 0 + ;; + + --run) + # Back-compat with the calling convention used by older automake. + shift + ;; + + -h|--h|--he|--hel|--help) + echo "\ +$0 [OPTION]... PROGRAM [ARGUMENT]... + +Run 'PROGRAM [ARGUMENT]...', returning a proper advice when this fails due +to PROGRAM being missing or too old. + +Options: + -h, --help display this help and exit + -v, --version output version information and exit + +Supported PROGRAM values: + aclocal autoconf autoheader autom4te automake makeinfo + bison yacc flex lex help2man + +Version suffixes to PROGRAM as well as the prefixes 'gnu-', 'gnu', and +'g' are ignored when checking the name. + +Send bug reports to ." + exit $? + ;; + + -v|--v|--ve|--ver|--vers|--versi|--versio|--version) + echo "missing $scriptversion (GNU Automake)" + exit $? + ;; + + -*) + echo 1>&2 "$0: unknown '$1' option" + echo 1>&2 "Try '$0 --help' for more information" + exit 1 + ;; + +esac + +# Run the given program, remember its exit status. +"$@"; st=$? + +# If it succeeded, we are done. +test $st -eq 0 && exit 0 + +# Also exit now if we it failed (or wasn't found), and '--version' was +# passed; such an option is passed most likely to detect whether the +# program is present and works. +case $2 in --version|--help) exit $st;; esac + +# Exit code 63 means version mismatch. This often happens when the user +# tries to use an ancient version of a tool on a file that requires a +# minimum version. +if test $st -eq 63; then + msg="probably too old" +elif test $st -eq 127; then + # Program was missing. + msg="missing on your system" +else + # Program was found and executed, but failed. Give up. + exit $st +fi + +perl_URL=http://www.perl.org/ +flex_URL=http://flex.sourceforge.net/ +gnu_software_URL=http://www.gnu.org/software + +program_details () +{ + case $1 in + aclocal|automake) + echo "The '$1' program is part of the GNU Automake package:" + echo "<$gnu_software_URL/automake>" + echo "It also requires GNU Autoconf, GNU m4 and Perl in order to run:" + echo "<$gnu_software_URL/autoconf>" + echo "<$gnu_software_URL/m4/>" + echo "<$perl_URL>" + ;; + autoconf|autom4te|autoheader) + echo "The '$1' program is part of the GNU Autoconf package:" + echo "<$gnu_software_URL/autoconf/>" + echo "It also requires GNU m4 and Perl in order to run:" + echo "<$gnu_software_URL/m4/>" + echo "<$perl_URL>" + ;; + esac +} + +give_advice () +{ + # Normalize program name to check for. + normalized_program=`echo "$1" | sed ' + s/^gnu-//; t + s/^gnu//; t + s/^g//; t'` + + printf '%s\n' "'$1' is $msg." + + configure_deps="'configure.ac' or m4 files included by 'configure.ac'" + case $normalized_program in + autoconf*) + echo "You should only need it if you modified 'configure.ac'," + echo "or m4 files included by it." + program_details 'autoconf' + ;; + autoheader*) + echo "You should only need it if you modified 'acconfig.h' or" + echo "$configure_deps." + program_details 'autoheader' + ;; + automake*) + echo "You should only need it if you modified 'Makefile.am' or" + echo "$configure_deps." + program_details 'automake' + ;; + aclocal*) + echo "You should only need it if you modified 'acinclude.m4' or" + echo "$configure_deps." + program_details 'aclocal' + ;; + autom4te*) + echo "You might have modified some maintainer files that require" + echo "the 'autom4te' program to be rebuilt." + program_details 'autom4te' + ;; + bison*|yacc*) + echo "You should only need it if you modified a '.y' file." + echo "You may want to install the GNU Bison package:" + echo "<$gnu_software_URL/bison/>" + ;; + lex*|flex*) + echo "You should only need it if you modified a '.l' file." + echo "You may want to install the Fast Lexical Analyzer package:" + echo "<$flex_URL>" + ;; + help2man*) + echo "You should only need it if you modified a dependency" \ + "of a man page." + echo "You may want to install the GNU Help2man package:" + echo "<$gnu_software_URL/help2man/>" + ;; + makeinfo*) + echo "You should only need it if you modified a '.texi' file, or" + echo "any other file indirectly affecting the aspect of the manual." + echo "You might want to install the Texinfo package:" + echo "<$gnu_software_URL/texinfo/>" + echo "The spurious makeinfo call might also be the consequence of" + echo "using a buggy 'make' (AIX, DU, IRIX), in which case you might" + echo "want to install GNU make:" + echo "<$gnu_software_URL/make/>" + ;; + *) + echo "You might have modified some files without having the proper" + echo "tools for further handling them. Check the 'README' file, it" + echo "often tells you about the needed prerequisites for installing" + echo "this package. You may also peek at any GNU archive site, in" + echo "case some other package contains this missing '$1' program." + ;; + esac +} + +give_advice "$1" | sed -e '1s/^/WARNING: /' \ + -e '2,$s/^/ /' >&2 + +# Propagate the correct exit status (expected to be 127 for a program +# not found, 63 for a program that failed due to version mismatch). +exit $st + +# Local variables: +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "scriptversion=" +# time-stamp-format: "%:y-%02m-%02d.%02H" +# time-stamp-time-zone: "UTC" +# time-stamp-end: "; # UTC" +# End: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/Makefile.am b/native_client/ctcdecode/third_party/openfst-1.6.7/src/Makefile.am new file mode 100644 index 0000000000..b3ca481cdd --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/Makefile.am @@ -0,0 +1 @@ +SUBDIRS = include lib script bin test extensions diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/Makefile.in b/native_client/ctcdecode/third_party/openfst-1.6.7/src/Makefile.in new file mode 100644 index 0000000000..afa52a8364 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/Makefile.in @@ -0,0 +1,624 @@ +# Makefile.in generated by automake 1.14.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2013 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ +VPATH = @srcdir@ +am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +subdir = src +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \ + $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ + $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ + $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h \ + $(top_builddir)/src/include/fst/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +SOURCES = +DIST_SOURCES = +RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \ + ctags-recursive dvi-recursive html-recursive info-recursive \ + install-data-recursive install-dvi-recursive \ + install-exec-recursive install-html-recursive \ + install-info-recursive install-pdf-recursive \ + install-ps-recursive install-recursive installcheck-recursive \ + installdirs-recursive pdf-recursive ps-recursive \ + tags-recursive uninstall-recursive +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \ + distclean-recursive maintainer-clean-recursive +am__recursive_targets = \ + $(RECURSIVE_TARGETS) \ + $(RECURSIVE_CLEAN_TARGETS) \ + $(am__extra_recursive_targets) +AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \ + distdir +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +DIST_SUBDIRS = $(SUBDIRS) +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +am__relativize = \ + dir0=`pwd`; \ + sed_first='s,^\([^/]*\)/.*$$,\1,'; \ + sed_rest='s,^[^/]*/*,,'; \ + sed_last='s,^.*/\([^/]*\)$$,\1,'; \ + sed_butlast='s,/*[^/]*$$,,'; \ + while test -n "$$dir1"; do \ + first=`echo "$$dir1" | sed -e "$$sed_first"`; \ + if test "$$first" != "."; then \ + if test "$$first" = ".."; then \ + dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \ + dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \ + else \ + first2=`echo "$$dir2" | sed -e "$$sed_first"`; \ + if test "$$first2" = "$$first"; then \ + dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \ + else \ + dir2="../$$dir2"; \ + fi; \ + dir0="$$dir0"/"$$first"; \ + fi; \ + fi; \ + dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \ + done; \ + reldir="$$dir2" +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DL_LIBS = @DL_LIBS@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PYTHON = @PYTHON@ +PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@ +PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ +PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@ +PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@ +PYTHON_LDFLAGS = @PYTHON_LDFLAGS@ +PYTHON_PLATFORM = @PYTHON_PLATFORM@ +PYTHON_PREFIX = @PYTHON_PREFIX@ +PYTHON_SITE_PKG = @PYTHON_SITE_PKG@ +PYTHON_VERSION = @PYTHON_VERSION@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +libfstdir = @libfstdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgpyexecdir = @pkgpyexecdir@ +pkgpythondir = @pkgpythondir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +pyexecdir = @pyexecdir@ +pythondir = @pythondir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +SUBDIRS = include lib script bin test extensions +all: all-recursive + +.SUFFIXES: +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign src/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +# This directory's subdirectories are mostly independent; you can cd +# into them and run 'make' without going through this Makefile. +# To change the values of 'make' variables: instead of editing Makefiles, +# (1) if the variable is set in 'config.status', edit 'config.status' +# (which will cause the Makefiles to be regenerated when you run 'make'); +# (2) otherwise, pass the desired values on the 'make' command line. +$(am__recursive_targets): + @fail=; \ + if $(am__make_keepgoing); then \ + failcom='fail=yes'; \ + else \ + failcom='exit 1'; \ + fi; \ + dot_seen=no; \ + target=`echo $@ | sed s/-recursive//`; \ + case "$@" in \ + distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \ + *) list='$(SUBDIRS)' ;; \ + esac; \ + for subdir in $$list; do \ + echo "Making $$target in $$subdir"; \ + if test "$$subdir" = "."; then \ + dot_seen=yes; \ + local_target="$$target-am"; \ + else \ + local_target="$$target"; \ + fi; \ + ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ + || eval $$failcom; \ + done; \ + if test "$$dot_seen" = "no"; then \ + $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \ + fi; test -z "$$fail" + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-recursive +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \ + include_option=--etags-include; \ + empty_fix=.; \ + else \ + include_option=--include; \ + empty_fix=; \ + fi; \ + list='$(SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + test ! -f $$subdir/TAGS || \ + set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \ + fi; \ + done; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-recursive + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscopelist: cscopelist-recursive + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done + @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + $(am__make_dryrun) \ + || test -d "$(distdir)/$$subdir" \ + || $(MKDIR_P) "$(distdir)/$$subdir" \ + || exit 1; \ + dir1=$$subdir; dir2="$(distdir)/$$subdir"; \ + $(am__relativize); \ + new_distdir=$$reldir; \ + dir1=$$subdir; dir2="$(top_distdir)"; \ + $(am__relativize); \ + new_top_distdir=$$reldir; \ + echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \ + echo " am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \ + ($(am__cd) $$subdir && \ + $(MAKE) $(AM_MAKEFLAGS) \ + top_distdir="$$new_top_distdir" \ + distdir="$$new_distdir" \ + am__remove_distdir=: \ + am__skip_length_check=: \ + am__skip_mode_fix=: \ + distdir) \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-recursive +all-am: Makefile +installdirs: installdirs-recursive +installdirs-am: +install: install-recursive +install-exec: install-exec-recursive +install-data: install-data-recursive +uninstall: uninstall-recursive + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-recursive +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-recursive + +clean-am: clean-generic clean-libtool mostlyclean-am + +distclean: distclean-recursive + -rm -f Makefile +distclean-am: clean-am distclean-generic distclean-tags + +dvi: dvi-recursive + +dvi-am: + +html: html-recursive + +html-am: + +info: info-recursive + +info-am: + +install-data-am: + +install-dvi: install-dvi-recursive + +install-dvi-am: + +install-exec-am: + +install-html: install-html-recursive + +install-html-am: + +install-info: install-info-recursive + +install-info-am: + +install-man: + +install-pdf: install-pdf-recursive + +install-pdf-am: + +install-ps: install-ps-recursive + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-recursive + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-recursive + +mostlyclean-am: mostlyclean-generic mostlyclean-libtool + +pdf: pdf-recursive + +pdf-am: + +ps: ps-recursive + +ps-am: + +uninstall-am: + +.MAKE: $(am__recursive_targets) install-am install-strip + +.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am check \ + check-am clean clean-generic clean-libtool cscopelist-am ctags \ + ctags-am distclean distclean-generic distclean-libtool \ + distclean-tags distdir dvi dvi-am html html-am info info-am \ + install install-am install-data install-data-am install-dvi \ + install-dvi-am install-exec install-exec-am install-html \ + install-html-am install-info install-info-am install-man \ + install-pdf install-pdf-am install-ps install-ps-am \ + install-strip installcheck installcheck-am installdirs \ + installdirs-am maintainer-clean maintainer-clean-generic \ + mostlyclean mostlyclean-generic mostlyclean-libtool pdf pdf-am \ + ps ps-am tags tags-am uninstall uninstall-am + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/Makefile.am b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/Makefile.am new file mode 100644 index 0000000000..b4069c4b25 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/Makefile.am @@ -0,0 +1,86 @@ +AM_CPPFLAGS = -I$(srcdir)/../include -I$(srcdir)/../script $(ICU_FLAGS) +LDADD = ../script/libfstscript.la ../lib/libfst.la -lm $(DL_LIBS) + +if HAVE_BIN +bin_PROGRAMS = fstarcsort fstclosure fstcompile fstcompose fstconcat \ +fstconnect fstconvert fstdeterminize fstdifference fstdisambiguate fstdraw \ +fstencode fstepsnormalize fstequal fstequivalent fstinfo fstintersect \ +fstinvert fstisomorphic fstmap fstminimize fstprint fstproject fstprune \ +fstpush fstrandgen fstrelabel fstreplace fstreverse fstreweight fstrmepsilon \ +fstshortestdistance fstshortestpath fstsymbols fstsynchronize fsttopsort \ +fstunion + +fstarcsort_SOURCES = fstarcsort.cc fstarcsort-main.cc + +fstclosure_SOURCES = fstclosure.cc fstclosure-main.cc + +fstcompile_SOURCES = fstcompile.cc fstcompile-main.cc + +fstcompose_SOURCES = fstcompose.cc fstcompose-main.cc + +fstconcat_SOURCES = fstconcat.cc fstconcat-main.cc + +fstconnect_SOURCES = fstconnect.cc fstconnect-main.cc + +fstconvert_SOURCES = fstconvert.cc fstconvert-main.cc + +fstdeterminize_SOURCES = fstdeterminize.cc fstdeterminize-main.cc + +fstdifference_SOURCES = fstdifference.cc fstdifference-main.cc + +fstdisambiguate_SOURCES = fstdisambiguate.cc fstdisambiguate-main.cc + +fstdraw_SOURCES = fstdraw.cc fstdraw-main.cc + +fstencode_SOURCES = fstencode.cc fstencode-main.cc + +fstepsnormalize_SOURCES = fstepsnormalize.cc fstepsnormalize-main.cc + +fstequal_SOURCES = fstequal.cc fstequal-main.cc + +fstequivalent_SOURCES = fstequivalent.cc fstequivalent-main.cc + +fstinfo_SOURCES = fstinfo.cc fstinfo-main.cc + +fstintersect_SOURCES = fstintersect.cc fstintersect-main.cc + +fstinvert_SOURCES = fstinvert.cc fstinvert-main.cc + +fstisomorphic_SOURCES = fstisomorphic.cc fstisomorphic-main.cc + +fstmap_SOURCES = fstmap.cc fstmap-main.cc + +fstminimize_SOURCES = fstminimize.cc fstminimize-main.cc + +fstprint_SOURCES = fstprint.cc fstprint-main.cc + +fstproject_SOURCES = fstproject.cc fstproject-main.cc + +fstprune_SOURCES = fstprune.cc fstprune-main.cc + +fstpush_SOURCES = fstpush.cc fstpush-main.cc + +fstrandgen_SOURCES = fstrandgen.cc fstrandgen-main.cc + +fstrelabel_SOURCES = fstrelabel.cc fstrelabel-main.cc + +fstreplace_SOURCES = fstreplace.cc fstreplace-main.cc + +fstreverse_SOURCES = fstreverse.cc fstreverse-main.cc + +fstreweight_SOURCES = fstreweight.cc fstreweight-main.cc + +fstrmepsilon_SOURCES = fstrmepsilon.cc fstrmepsilon-main.cc + +fstshortestdistance_SOURCES = fstshortestdistance.cc fstshortestdistance-main.cc + +fstshortestpath_SOURCES = fstshortestpath.cc fstshortestpath-main.cc + +fstsymbols_SOURCES = fstsymbols.cc fstsymbols-main.cc + +fstsynchronize_SOURCES = fstsynchronize.cc fstsynchronize-main.cc + +fsttopsort_SOURCES = fsttopsort.cc fsttopsort-main.cc + +fstunion_SOURCES = fstunion.cc fstunion-main.cc +endif diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/Makefile.in b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/Makefile.in new file mode 100644 index 0000000000..dae292b2ba --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/Makefile.in @@ -0,0 +1,1218 @@ +# Makefile.in generated by automake 1.14.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2013 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +VPATH = @srcdir@ +am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +@HAVE_BIN_TRUE@bin_PROGRAMS = fstarcsort$(EXEEXT) fstclosure$(EXEEXT) \ +@HAVE_BIN_TRUE@ fstcompile$(EXEEXT) fstcompose$(EXEEXT) \ +@HAVE_BIN_TRUE@ fstconcat$(EXEEXT) fstconnect$(EXEEXT) \ +@HAVE_BIN_TRUE@ fstconvert$(EXEEXT) fstdeterminize$(EXEEXT) \ +@HAVE_BIN_TRUE@ fstdifference$(EXEEXT) fstdisambiguate$(EXEEXT) \ +@HAVE_BIN_TRUE@ fstdraw$(EXEEXT) fstencode$(EXEEXT) \ +@HAVE_BIN_TRUE@ fstepsnormalize$(EXEEXT) fstequal$(EXEEXT) \ +@HAVE_BIN_TRUE@ fstequivalent$(EXEEXT) fstinfo$(EXEEXT) \ +@HAVE_BIN_TRUE@ fstintersect$(EXEEXT) fstinvert$(EXEEXT) \ +@HAVE_BIN_TRUE@ fstisomorphic$(EXEEXT) fstmap$(EXEEXT) \ +@HAVE_BIN_TRUE@ fstminimize$(EXEEXT) fstprint$(EXEEXT) \ +@HAVE_BIN_TRUE@ fstproject$(EXEEXT) fstprune$(EXEEXT) \ +@HAVE_BIN_TRUE@ fstpush$(EXEEXT) fstrandgen$(EXEEXT) \ +@HAVE_BIN_TRUE@ fstrelabel$(EXEEXT) fstreplace$(EXEEXT) \ +@HAVE_BIN_TRUE@ fstreverse$(EXEEXT) fstreweight$(EXEEXT) \ +@HAVE_BIN_TRUE@ fstrmepsilon$(EXEEXT) \ +@HAVE_BIN_TRUE@ fstshortestdistance$(EXEEXT) \ +@HAVE_BIN_TRUE@ fstshortestpath$(EXEEXT) fstsymbols$(EXEEXT) \ +@HAVE_BIN_TRUE@ fstsynchronize$(EXEEXT) fsttopsort$(EXEEXT) \ +@HAVE_BIN_TRUE@ fstunion$(EXEEXT) +subdir = src/bin +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ + $(top_srcdir)/depcomp +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \ + $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ + $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ + $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h \ + $(top_builddir)/src/include/fst/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +am__installdirs = "$(DESTDIR)$(bindir)" +PROGRAMS = $(bin_PROGRAMS) +am__fstarcsort_SOURCES_DIST = fstarcsort.cc fstarcsort-main.cc +@HAVE_BIN_TRUE@am_fstarcsort_OBJECTS = fstarcsort.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstarcsort-main.$(OBJEXT) +fstarcsort_OBJECTS = $(am_fstarcsort_OBJECTS) +fstarcsort_LDADD = $(LDADD) +am__DEPENDENCIES_1 = +fstarcsort_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +AM_V_lt = $(am__v_lt_@AM_V@) +am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) +am__v_lt_0 = --silent +am__v_lt_1 = +am__fstclosure_SOURCES_DIST = fstclosure.cc fstclosure-main.cc +@HAVE_BIN_TRUE@am_fstclosure_OBJECTS = fstclosure.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstclosure-main.$(OBJEXT) +fstclosure_OBJECTS = $(am_fstclosure_OBJECTS) +fstclosure_LDADD = $(LDADD) +fstclosure_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstcompile_SOURCES_DIST = fstcompile.cc fstcompile-main.cc +@HAVE_BIN_TRUE@am_fstcompile_OBJECTS = fstcompile.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstcompile-main.$(OBJEXT) +fstcompile_OBJECTS = $(am_fstcompile_OBJECTS) +fstcompile_LDADD = $(LDADD) +fstcompile_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstcompose_SOURCES_DIST = fstcompose.cc fstcompose-main.cc +@HAVE_BIN_TRUE@am_fstcompose_OBJECTS = fstcompose.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstcompose-main.$(OBJEXT) +fstcompose_OBJECTS = $(am_fstcompose_OBJECTS) +fstcompose_LDADD = $(LDADD) +fstcompose_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstconcat_SOURCES_DIST = fstconcat.cc fstconcat-main.cc +@HAVE_BIN_TRUE@am_fstconcat_OBJECTS = fstconcat.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstconcat-main.$(OBJEXT) +fstconcat_OBJECTS = $(am_fstconcat_OBJECTS) +fstconcat_LDADD = $(LDADD) +fstconcat_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstconnect_SOURCES_DIST = fstconnect.cc fstconnect-main.cc +@HAVE_BIN_TRUE@am_fstconnect_OBJECTS = fstconnect.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstconnect-main.$(OBJEXT) +fstconnect_OBJECTS = $(am_fstconnect_OBJECTS) +fstconnect_LDADD = $(LDADD) +fstconnect_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstconvert_SOURCES_DIST = fstconvert.cc fstconvert-main.cc +@HAVE_BIN_TRUE@am_fstconvert_OBJECTS = fstconvert.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstconvert-main.$(OBJEXT) +fstconvert_OBJECTS = $(am_fstconvert_OBJECTS) +fstconvert_LDADD = $(LDADD) +fstconvert_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstdeterminize_SOURCES_DIST = fstdeterminize.cc \ + fstdeterminize-main.cc +@HAVE_BIN_TRUE@am_fstdeterminize_OBJECTS = fstdeterminize.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstdeterminize-main.$(OBJEXT) +fstdeterminize_OBJECTS = $(am_fstdeterminize_OBJECTS) +fstdeterminize_LDADD = $(LDADD) +fstdeterminize_DEPENDENCIES = ../script/libfstscript.la \ + ../lib/libfst.la $(am__DEPENDENCIES_1) +am__fstdifference_SOURCES_DIST = fstdifference.cc \ + fstdifference-main.cc +@HAVE_BIN_TRUE@am_fstdifference_OBJECTS = fstdifference.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstdifference-main.$(OBJEXT) +fstdifference_OBJECTS = $(am_fstdifference_OBJECTS) +fstdifference_LDADD = $(LDADD) +fstdifference_DEPENDENCIES = ../script/libfstscript.la \ + ../lib/libfst.la $(am__DEPENDENCIES_1) +am__fstdisambiguate_SOURCES_DIST = fstdisambiguate.cc \ + fstdisambiguate-main.cc +@HAVE_BIN_TRUE@am_fstdisambiguate_OBJECTS = fstdisambiguate.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstdisambiguate-main.$(OBJEXT) +fstdisambiguate_OBJECTS = $(am_fstdisambiguate_OBJECTS) +fstdisambiguate_LDADD = $(LDADD) +fstdisambiguate_DEPENDENCIES = ../script/libfstscript.la \ + ../lib/libfst.la $(am__DEPENDENCIES_1) +am__fstdraw_SOURCES_DIST = fstdraw.cc fstdraw-main.cc +@HAVE_BIN_TRUE@am_fstdraw_OBJECTS = fstdraw.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstdraw-main.$(OBJEXT) +fstdraw_OBJECTS = $(am_fstdraw_OBJECTS) +fstdraw_LDADD = $(LDADD) +fstdraw_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstencode_SOURCES_DIST = fstencode.cc fstencode-main.cc +@HAVE_BIN_TRUE@am_fstencode_OBJECTS = fstencode.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstencode-main.$(OBJEXT) +fstencode_OBJECTS = $(am_fstencode_OBJECTS) +fstencode_LDADD = $(LDADD) +fstencode_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstepsnormalize_SOURCES_DIST = fstepsnormalize.cc \ + fstepsnormalize-main.cc +@HAVE_BIN_TRUE@am_fstepsnormalize_OBJECTS = fstepsnormalize.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstepsnormalize-main.$(OBJEXT) +fstepsnormalize_OBJECTS = $(am_fstepsnormalize_OBJECTS) +fstepsnormalize_LDADD = $(LDADD) +fstepsnormalize_DEPENDENCIES = ../script/libfstscript.la \ + ../lib/libfst.la $(am__DEPENDENCIES_1) +am__fstequal_SOURCES_DIST = fstequal.cc fstequal-main.cc +@HAVE_BIN_TRUE@am_fstequal_OBJECTS = fstequal.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstequal-main.$(OBJEXT) +fstequal_OBJECTS = $(am_fstequal_OBJECTS) +fstequal_LDADD = $(LDADD) +fstequal_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstequivalent_SOURCES_DIST = fstequivalent.cc \ + fstequivalent-main.cc +@HAVE_BIN_TRUE@am_fstequivalent_OBJECTS = fstequivalent.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstequivalent-main.$(OBJEXT) +fstequivalent_OBJECTS = $(am_fstequivalent_OBJECTS) +fstequivalent_LDADD = $(LDADD) +fstequivalent_DEPENDENCIES = ../script/libfstscript.la \ + ../lib/libfst.la $(am__DEPENDENCIES_1) +am__fstinfo_SOURCES_DIST = fstinfo.cc fstinfo-main.cc +@HAVE_BIN_TRUE@am_fstinfo_OBJECTS = fstinfo.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstinfo-main.$(OBJEXT) +fstinfo_OBJECTS = $(am_fstinfo_OBJECTS) +fstinfo_LDADD = $(LDADD) +fstinfo_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstintersect_SOURCES_DIST = fstintersect.cc fstintersect-main.cc +@HAVE_BIN_TRUE@am_fstintersect_OBJECTS = fstintersect.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstintersect-main.$(OBJEXT) +fstintersect_OBJECTS = $(am_fstintersect_OBJECTS) +fstintersect_LDADD = $(LDADD) +fstintersect_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstinvert_SOURCES_DIST = fstinvert.cc fstinvert-main.cc +@HAVE_BIN_TRUE@am_fstinvert_OBJECTS = fstinvert.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstinvert-main.$(OBJEXT) +fstinvert_OBJECTS = $(am_fstinvert_OBJECTS) +fstinvert_LDADD = $(LDADD) +fstinvert_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstisomorphic_SOURCES_DIST = fstisomorphic.cc \ + fstisomorphic-main.cc +@HAVE_BIN_TRUE@am_fstisomorphic_OBJECTS = fstisomorphic.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstisomorphic-main.$(OBJEXT) +fstisomorphic_OBJECTS = $(am_fstisomorphic_OBJECTS) +fstisomorphic_LDADD = $(LDADD) +fstisomorphic_DEPENDENCIES = ../script/libfstscript.la \ + ../lib/libfst.la $(am__DEPENDENCIES_1) +am__fstmap_SOURCES_DIST = fstmap.cc fstmap-main.cc +@HAVE_BIN_TRUE@am_fstmap_OBJECTS = fstmap.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstmap-main.$(OBJEXT) +fstmap_OBJECTS = $(am_fstmap_OBJECTS) +fstmap_LDADD = $(LDADD) +fstmap_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstminimize_SOURCES_DIST = fstminimize.cc fstminimize-main.cc +@HAVE_BIN_TRUE@am_fstminimize_OBJECTS = fstminimize.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstminimize-main.$(OBJEXT) +fstminimize_OBJECTS = $(am_fstminimize_OBJECTS) +fstminimize_LDADD = $(LDADD) +fstminimize_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstprint_SOURCES_DIST = fstprint.cc fstprint-main.cc +@HAVE_BIN_TRUE@am_fstprint_OBJECTS = fstprint.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstprint-main.$(OBJEXT) +fstprint_OBJECTS = $(am_fstprint_OBJECTS) +fstprint_LDADD = $(LDADD) +fstprint_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstproject_SOURCES_DIST = fstproject.cc fstproject-main.cc +@HAVE_BIN_TRUE@am_fstproject_OBJECTS = fstproject.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstproject-main.$(OBJEXT) +fstproject_OBJECTS = $(am_fstproject_OBJECTS) +fstproject_LDADD = $(LDADD) +fstproject_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstprune_SOURCES_DIST = fstprune.cc fstprune-main.cc +@HAVE_BIN_TRUE@am_fstprune_OBJECTS = fstprune.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstprune-main.$(OBJEXT) +fstprune_OBJECTS = $(am_fstprune_OBJECTS) +fstprune_LDADD = $(LDADD) +fstprune_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstpush_SOURCES_DIST = fstpush.cc fstpush-main.cc +@HAVE_BIN_TRUE@am_fstpush_OBJECTS = fstpush.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstpush-main.$(OBJEXT) +fstpush_OBJECTS = $(am_fstpush_OBJECTS) +fstpush_LDADD = $(LDADD) +fstpush_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstrandgen_SOURCES_DIST = fstrandgen.cc fstrandgen-main.cc +@HAVE_BIN_TRUE@am_fstrandgen_OBJECTS = fstrandgen.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstrandgen-main.$(OBJEXT) +fstrandgen_OBJECTS = $(am_fstrandgen_OBJECTS) +fstrandgen_LDADD = $(LDADD) +fstrandgen_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstrelabel_SOURCES_DIST = fstrelabel.cc fstrelabel-main.cc +@HAVE_BIN_TRUE@am_fstrelabel_OBJECTS = fstrelabel.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstrelabel-main.$(OBJEXT) +fstrelabel_OBJECTS = $(am_fstrelabel_OBJECTS) +fstrelabel_LDADD = $(LDADD) +fstrelabel_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstreplace_SOURCES_DIST = fstreplace.cc fstreplace-main.cc +@HAVE_BIN_TRUE@am_fstreplace_OBJECTS = fstreplace.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstreplace-main.$(OBJEXT) +fstreplace_OBJECTS = $(am_fstreplace_OBJECTS) +fstreplace_LDADD = $(LDADD) +fstreplace_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstreverse_SOURCES_DIST = fstreverse.cc fstreverse-main.cc +@HAVE_BIN_TRUE@am_fstreverse_OBJECTS = fstreverse.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstreverse-main.$(OBJEXT) +fstreverse_OBJECTS = $(am_fstreverse_OBJECTS) +fstreverse_LDADD = $(LDADD) +fstreverse_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstreweight_SOURCES_DIST = fstreweight.cc fstreweight-main.cc +@HAVE_BIN_TRUE@am_fstreweight_OBJECTS = fstreweight.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstreweight-main.$(OBJEXT) +fstreweight_OBJECTS = $(am_fstreweight_OBJECTS) +fstreweight_LDADD = $(LDADD) +fstreweight_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstrmepsilon_SOURCES_DIST = fstrmepsilon.cc fstrmepsilon-main.cc +@HAVE_BIN_TRUE@am_fstrmepsilon_OBJECTS = fstrmepsilon.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstrmepsilon-main.$(OBJEXT) +fstrmepsilon_OBJECTS = $(am_fstrmepsilon_OBJECTS) +fstrmepsilon_LDADD = $(LDADD) +fstrmepsilon_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstshortestdistance_SOURCES_DIST = fstshortestdistance.cc \ + fstshortestdistance-main.cc +@HAVE_BIN_TRUE@am_fstshortestdistance_OBJECTS = \ +@HAVE_BIN_TRUE@ fstshortestdistance.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstshortestdistance-main.$(OBJEXT) +fstshortestdistance_OBJECTS = $(am_fstshortestdistance_OBJECTS) +fstshortestdistance_LDADD = $(LDADD) +fstshortestdistance_DEPENDENCIES = ../script/libfstscript.la \ + ../lib/libfst.la $(am__DEPENDENCIES_1) +am__fstshortestpath_SOURCES_DIST = fstshortestpath.cc \ + fstshortestpath-main.cc +@HAVE_BIN_TRUE@am_fstshortestpath_OBJECTS = fstshortestpath.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstshortestpath-main.$(OBJEXT) +fstshortestpath_OBJECTS = $(am_fstshortestpath_OBJECTS) +fstshortestpath_LDADD = $(LDADD) +fstshortestpath_DEPENDENCIES = ../script/libfstscript.la \ + ../lib/libfst.la $(am__DEPENDENCIES_1) +am__fstsymbols_SOURCES_DIST = fstsymbols.cc fstsymbols-main.cc +@HAVE_BIN_TRUE@am_fstsymbols_OBJECTS = fstsymbols.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstsymbols-main.$(OBJEXT) +fstsymbols_OBJECTS = $(am_fstsymbols_OBJECTS) +fstsymbols_LDADD = $(LDADD) +fstsymbols_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstsynchronize_SOURCES_DIST = fstsynchronize.cc \ + fstsynchronize-main.cc +@HAVE_BIN_TRUE@am_fstsynchronize_OBJECTS = fstsynchronize.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstsynchronize-main.$(OBJEXT) +fstsynchronize_OBJECTS = $(am_fstsynchronize_OBJECTS) +fstsynchronize_LDADD = $(LDADD) +fstsynchronize_DEPENDENCIES = ../script/libfstscript.la \ + ../lib/libfst.la $(am__DEPENDENCIES_1) +am__fsttopsort_SOURCES_DIST = fsttopsort.cc fsttopsort-main.cc +@HAVE_BIN_TRUE@am_fsttopsort_OBJECTS = fsttopsort.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fsttopsort-main.$(OBJEXT) +fsttopsort_OBJECTS = $(am_fsttopsort_OBJECTS) +fsttopsort_LDADD = $(LDADD) +fsttopsort_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am__fstunion_SOURCES_DIST = fstunion.cc fstunion-main.cc +@HAVE_BIN_TRUE@am_fstunion_OBJECTS = fstunion.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstunion-main.$(OBJEXT) +fstunion_OBJECTS = $(am_fstunion_OBJECTS) +fstunion_LDADD = $(LDADD) +fstunion_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +DEFAULT_INCLUDES = +depcomp = $(SHELL) $(top_srcdir)/depcomp +am__depfiles_maybe = depfiles +am__mv = mv -f +CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CXXFLAGS) $(CXXFLAGS) +AM_V_CXX = $(am__v_CXX_@AM_V@) +am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@) +am__v_CXX_0 = @echo " CXX " $@; +am__v_CXX_1 = +CXXLD = $(CXX) +CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_CXXLD = $(am__v_CXXLD_@AM_V@) +am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@) +am__v_CXXLD_0 = @echo " CXXLD " $@; +am__v_CXXLD_1 = +SOURCES = $(fstarcsort_SOURCES) $(fstclosure_SOURCES) \ + $(fstcompile_SOURCES) $(fstcompose_SOURCES) \ + $(fstconcat_SOURCES) $(fstconnect_SOURCES) \ + $(fstconvert_SOURCES) $(fstdeterminize_SOURCES) \ + $(fstdifference_SOURCES) $(fstdisambiguate_SOURCES) \ + $(fstdraw_SOURCES) $(fstencode_SOURCES) \ + $(fstepsnormalize_SOURCES) $(fstequal_SOURCES) \ + $(fstequivalent_SOURCES) $(fstinfo_SOURCES) \ + $(fstintersect_SOURCES) $(fstinvert_SOURCES) \ + $(fstisomorphic_SOURCES) $(fstmap_SOURCES) \ + $(fstminimize_SOURCES) $(fstprint_SOURCES) \ + $(fstproject_SOURCES) $(fstprune_SOURCES) $(fstpush_SOURCES) \ + $(fstrandgen_SOURCES) $(fstrelabel_SOURCES) \ + $(fstreplace_SOURCES) $(fstreverse_SOURCES) \ + $(fstreweight_SOURCES) $(fstrmepsilon_SOURCES) \ + $(fstshortestdistance_SOURCES) $(fstshortestpath_SOURCES) \ + $(fstsymbols_SOURCES) $(fstsynchronize_SOURCES) \ + $(fsttopsort_SOURCES) $(fstunion_SOURCES) +DIST_SOURCES = $(am__fstarcsort_SOURCES_DIST) \ + $(am__fstclosure_SOURCES_DIST) $(am__fstcompile_SOURCES_DIST) \ + $(am__fstcompose_SOURCES_DIST) $(am__fstconcat_SOURCES_DIST) \ + $(am__fstconnect_SOURCES_DIST) $(am__fstconvert_SOURCES_DIST) \ + $(am__fstdeterminize_SOURCES_DIST) \ + $(am__fstdifference_SOURCES_DIST) \ + $(am__fstdisambiguate_SOURCES_DIST) \ + $(am__fstdraw_SOURCES_DIST) $(am__fstencode_SOURCES_DIST) \ + $(am__fstepsnormalize_SOURCES_DIST) \ + $(am__fstequal_SOURCES_DIST) $(am__fstequivalent_SOURCES_DIST) \ + $(am__fstinfo_SOURCES_DIST) $(am__fstintersect_SOURCES_DIST) \ + $(am__fstinvert_SOURCES_DIST) \ + $(am__fstisomorphic_SOURCES_DIST) $(am__fstmap_SOURCES_DIST) \ + $(am__fstminimize_SOURCES_DIST) $(am__fstprint_SOURCES_DIST) \ + $(am__fstproject_SOURCES_DIST) $(am__fstprune_SOURCES_DIST) \ + $(am__fstpush_SOURCES_DIST) $(am__fstrandgen_SOURCES_DIST) \ + $(am__fstrelabel_SOURCES_DIST) $(am__fstreplace_SOURCES_DIST) \ + $(am__fstreverse_SOURCES_DIST) $(am__fstreweight_SOURCES_DIST) \ + $(am__fstrmepsilon_SOURCES_DIST) \ + $(am__fstshortestdistance_SOURCES_DIST) \ + $(am__fstshortestpath_SOURCES_DIST) \ + $(am__fstsymbols_SOURCES_DIST) \ + $(am__fstsynchronize_SOURCES_DIST) \ + $(am__fsttopsort_SOURCES_DIST) $(am__fstunion_SOURCES_DIST) +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DL_LIBS = @DL_LIBS@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PYTHON = @PYTHON@ +PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@ +PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ +PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@ +PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@ +PYTHON_LDFLAGS = @PYTHON_LDFLAGS@ +PYTHON_PLATFORM = @PYTHON_PLATFORM@ +PYTHON_PREFIX = @PYTHON_PREFIX@ +PYTHON_SITE_PKG = @PYTHON_SITE_PKG@ +PYTHON_VERSION = @PYTHON_VERSION@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +libfstdir = @libfstdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgpyexecdir = @pkgpyexecdir@ +pkgpythondir = @pkgpythondir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +pyexecdir = @pyexecdir@ +pythondir = @pythondir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +AM_CPPFLAGS = -I$(srcdir)/../include -I$(srcdir)/../script $(ICU_FLAGS) +LDADD = ../script/libfstscript.la ../lib/libfst.la -lm $(DL_LIBS) +@HAVE_BIN_TRUE@fstarcsort_SOURCES = fstarcsort.cc fstarcsort-main.cc +@HAVE_BIN_TRUE@fstclosure_SOURCES = fstclosure.cc fstclosure-main.cc +@HAVE_BIN_TRUE@fstcompile_SOURCES = fstcompile.cc fstcompile-main.cc +@HAVE_BIN_TRUE@fstcompose_SOURCES = fstcompose.cc fstcompose-main.cc +@HAVE_BIN_TRUE@fstconcat_SOURCES = fstconcat.cc fstconcat-main.cc +@HAVE_BIN_TRUE@fstconnect_SOURCES = fstconnect.cc fstconnect-main.cc +@HAVE_BIN_TRUE@fstconvert_SOURCES = fstconvert.cc fstconvert-main.cc +@HAVE_BIN_TRUE@fstdeterminize_SOURCES = fstdeterminize.cc fstdeterminize-main.cc +@HAVE_BIN_TRUE@fstdifference_SOURCES = fstdifference.cc fstdifference-main.cc +@HAVE_BIN_TRUE@fstdisambiguate_SOURCES = fstdisambiguate.cc fstdisambiguate-main.cc +@HAVE_BIN_TRUE@fstdraw_SOURCES = fstdraw.cc fstdraw-main.cc +@HAVE_BIN_TRUE@fstencode_SOURCES = fstencode.cc fstencode-main.cc +@HAVE_BIN_TRUE@fstepsnormalize_SOURCES = fstepsnormalize.cc fstepsnormalize-main.cc +@HAVE_BIN_TRUE@fstequal_SOURCES = fstequal.cc fstequal-main.cc +@HAVE_BIN_TRUE@fstequivalent_SOURCES = fstequivalent.cc fstequivalent-main.cc +@HAVE_BIN_TRUE@fstinfo_SOURCES = fstinfo.cc fstinfo-main.cc +@HAVE_BIN_TRUE@fstintersect_SOURCES = fstintersect.cc fstintersect-main.cc +@HAVE_BIN_TRUE@fstinvert_SOURCES = fstinvert.cc fstinvert-main.cc +@HAVE_BIN_TRUE@fstisomorphic_SOURCES = fstisomorphic.cc fstisomorphic-main.cc +@HAVE_BIN_TRUE@fstmap_SOURCES = fstmap.cc fstmap-main.cc +@HAVE_BIN_TRUE@fstminimize_SOURCES = fstminimize.cc fstminimize-main.cc +@HAVE_BIN_TRUE@fstprint_SOURCES = fstprint.cc fstprint-main.cc +@HAVE_BIN_TRUE@fstproject_SOURCES = fstproject.cc fstproject-main.cc +@HAVE_BIN_TRUE@fstprune_SOURCES = fstprune.cc fstprune-main.cc +@HAVE_BIN_TRUE@fstpush_SOURCES = fstpush.cc fstpush-main.cc +@HAVE_BIN_TRUE@fstrandgen_SOURCES = fstrandgen.cc fstrandgen-main.cc +@HAVE_BIN_TRUE@fstrelabel_SOURCES = fstrelabel.cc fstrelabel-main.cc +@HAVE_BIN_TRUE@fstreplace_SOURCES = fstreplace.cc fstreplace-main.cc +@HAVE_BIN_TRUE@fstreverse_SOURCES = fstreverse.cc fstreverse-main.cc +@HAVE_BIN_TRUE@fstreweight_SOURCES = fstreweight.cc fstreweight-main.cc +@HAVE_BIN_TRUE@fstrmepsilon_SOURCES = fstrmepsilon.cc fstrmepsilon-main.cc +@HAVE_BIN_TRUE@fstshortestdistance_SOURCES = fstshortestdistance.cc fstshortestdistance-main.cc +@HAVE_BIN_TRUE@fstshortestpath_SOURCES = fstshortestpath.cc fstshortestpath-main.cc +@HAVE_BIN_TRUE@fstsymbols_SOURCES = fstsymbols.cc fstsymbols-main.cc +@HAVE_BIN_TRUE@fstsynchronize_SOURCES = fstsynchronize.cc fstsynchronize-main.cc +@HAVE_BIN_TRUE@fsttopsort_SOURCES = fsttopsort.cc fsttopsort-main.cc +@HAVE_BIN_TRUE@fstunion_SOURCES = fstunion.cc fstunion-main.cc +all: all-am + +.SUFFIXES: +.SUFFIXES: .cc .lo .o .obj +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/bin/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign src/bin/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): +install-binPROGRAMS: $(bin_PROGRAMS) + @$(NORMAL_INSTALL) + @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \ + if test -n "$$list"; then \ + echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \ + fi; \ + for p in $$list; do echo "$$p $$p"; done | \ + sed 's/$(EXEEXT)$$//' | \ + while read p p1; do if test -f $$p \ + || test -f $$p1 \ + ; then echo "$$p"; echo "$$p"; else :; fi; \ + done | \ + sed -e 'p;s,.*/,,;n;h' \ + -e 's|.*|.|' \ + -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \ + sed 'N;N;N;s,\n, ,g' | \ + $(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \ + { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \ + if ($$2 == $$4) files[d] = files[d] " " $$1; \ + else { print "f", $$3 "/" $$4, $$1; } } \ + END { for (d in files) print "f", d, files[d] }' | \ + while read type dir files; do \ + if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \ + test -z "$$files" || { \ + echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \ + $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \ + } \ + ; done + +uninstall-binPROGRAMS: + @$(NORMAL_UNINSTALL) + @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \ + files=`for p in $$list; do echo "$$p"; done | \ + sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \ + -e 's/$$/$(EXEEXT)/' \ + `; \ + test -n "$$list" || exit 0; \ + echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(bindir)" && rm -f $$files + +clean-binPROGRAMS: + @list='$(bin_PROGRAMS)'; test -n "$$list" || exit 0; \ + echo " rm -f" $$list; \ + rm -f $$list || exit $$?; \ + test -n "$(EXEEXT)" || exit 0; \ + list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \ + echo " rm -f" $$list; \ + rm -f $$list + +fstarcsort$(EXEEXT): $(fstarcsort_OBJECTS) $(fstarcsort_DEPENDENCIES) $(EXTRA_fstarcsort_DEPENDENCIES) + @rm -f fstarcsort$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstarcsort_OBJECTS) $(fstarcsort_LDADD) $(LIBS) + +fstclosure$(EXEEXT): $(fstclosure_OBJECTS) $(fstclosure_DEPENDENCIES) $(EXTRA_fstclosure_DEPENDENCIES) + @rm -f fstclosure$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstclosure_OBJECTS) $(fstclosure_LDADD) $(LIBS) + +fstcompile$(EXEEXT): $(fstcompile_OBJECTS) $(fstcompile_DEPENDENCIES) $(EXTRA_fstcompile_DEPENDENCIES) + @rm -f fstcompile$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstcompile_OBJECTS) $(fstcompile_LDADD) $(LIBS) + +fstcompose$(EXEEXT): $(fstcompose_OBJECTS) $(fstcompose_DEPENDENCIES) $(EXTRA_fstcompose_DEPENDENCIES) + @rm -f fstcompose$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstcompose_OBJECTS) $(fstcompose_LDADD) $(LIBS) + +fstconcat$(EXEEXT): $(fstconcat_OBJECTS) $(fstconcat_DEPENDENCIES) $(EXTRA_fstconcat_DEPENDENCIES) + @rm -f fstconcat$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstconcat_OBJECTS) $(fstconcat_LDADD) $(LIBS) + +fstconnect$(EXEEXT): $(fstconnect_OBJECTS) $(fstconnect_DEPENDENCIES) $(EXTRA_fstconnect_DEPENDENCIES) + @rm -f fstconnect$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstconnect_OBJECTS) $(fstconnect_LDADD) $(LIBS) + +fstconvert$(EXEEXT): $(fstconvert_OBJECTS) $(fstconvert_DEPENDENCIES) $(EXTRA_fstconvert_DEPENDENCIES) + @rm -f fstconvert$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstconvert_OBJECTS) $(fstconvert_LDADD) $(LIBS) + +fstdeterminize$(EXEEXT): $(fstdeterminize_OBJECTS) $(fstdeterminize_DEPENDENCIES) $(EXTRA_fstdeterminize_DEPENDENCIES) + @rm -f fstdeterminize$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstdeterminize_OBJECTS) $(fstdeterminize_LDADD) $(LIBS) + +fstdifference$(EXEEXT): $(fstdifference_OBJECTS) $(fstdifference_DEPENDENCIES) $(EXTRA_fstdifference_DEPENDENCIES) + @rm -f fstdifference$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstdifference_OBJECTS) $(fstdifference_LDADD) $(LIBS) + +fstdisambiguate$(EXEEXT): $(fstdisambiguate_OBJECTS) $(fstdisambiguate_DEPENDENCIES) $(EXTRA_fstdisambiguate_DEPENDENCIES) + @rm -f fstdisambiguate$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstdisambiguate_OBJECTS) $(fstdisambiguate_LDADD) $(LIBS) + +fstdraw$(EXEEXT): $(fstdraw_OBJECTS) $(fstdraw_DEPENDENCIES) $(EXTRA_fstdraw_DEPENDENCIES) + @rm -f fstdraw$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstdraw_OBJECTS) $(fstdraw_LDADD) $(LIBS) + +fstencode$(EXEEXT): $(fstencode_OBJECTS) $(fstencode_DEPENDENCIES) $(EXTRA_fstencode_DEPENDENCIES) + @rm -f fstencode$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstencode_OBJECTS) $(fstencode_LDADD) $(LIBS) + +fstepsnormalize$(EXEEXT): $(fstepsnormalize_OBJECTS) $(fstepsnormalize_DEPENDENCIES) $(EXTRA_fstepsnormalize_DEPENDENCIES) + @rm -f fstepsnormalize$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstepsnormalize_OBJECTS) $(fstepsnormalize_LDADD) $(LIBS) + +fstequal$(EXEEXT): $(fstequal_OBJECTS) $(fstequal_DEPENDENCIES) $(EXTRA_fstequal_DEPENDENCIES) + @rm -f fstequal$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstequal_OBJECTS) $(fstequal_LDADD) $(LIBS) + +fstequivalent$(EXEEXT): $(fstequivalent_OBJECTS) $(fstequivalent_DEPENDENCIES) $(EXTRA_fstequivalent_DEPENDENCIES) + @rm -f fstequivalent$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstequivalent_OBJECTS) $(fstequivalent_LDADD) $(LIBS) + +fstinfo$(EXEEXT): $(fstinfo_OBJECTS) $(fstinfo_DEPENDENCIES) $(EXTRA_fstinfo_DEPENDENCIES) + @rm -f fstinfo$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstinfo_OBJECTS) $(fstinfo_LDADD) $(LIBS) + +fstintersect$(EXEEXT): $(fstintersect_OBJECTS) $(fstintersect_DEPENDENCIES) $(EXTRA_fstintersect_DEPENDENCIES) + @rm -f fstintersect$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstintersect_OBJECTS) $(fstintersect_LDADD) $(LIBS) + +fstinvert$(EXEEXT): $(fstinvert_OBJECTS) $(fstinvert_DEPENDENCIES) $(EXTRA_fstinvert_DEPENDENCIES) + @rm -f fstinvert$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstinvert_OBJECTS) $(fstinvert_LDADD) $(LIBS) + +fstisomorphic$(EXEEXT): $(fstisomorphic_OBJECTS) $(fstisomorphic_DEPENDENCIES) $(EXTRA_fstisomorphic_DEPENDENCIES) + @rm -f fstisomorphic$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstisomorphic_OBJECTS) $(fstisomorphic_LDADD) $(LIBS) + +fstmap$(EXEEXT): $(fstmap_OBJECTS) $(fstmap_DEPENDENCIES) $(EXTRA_fstmap_DEPENDENCIES) + @rm -f fstmap$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstmap_OBJECTS) $(fstmap_LDADD) $(LIBS) + +fstminimize$(EXEEXT): $(fstminimize_OBJECTS) $(fstminimize_DEPENDENCIES) $(EXTRA_fstminimize_DEPENDENCIES) + @rm -f fstminimize$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstminimize_OBJECTS) $(fstminimize_LDADD) $(LIBS) + +fstprint$(EXEEXT): $(fstprint_OBJECTS) $(fstprint_DEPENDENCIES) $(EXTRA_fstprint_DEPENDENCIES) + @rm -f fstprint$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstprint_OBJECTS) $(fstprint_LDADD) $(LIBS) + +fstproject$(EXEEXT): $(fstproject_OBJECTS) $(fstproject_DEPENDENCIES) $(EXTRA_fstproject_DEPENDENCIES) + @rm -f fstproject$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstproject_OBJECTS) $(fstproject_LDADD) $(LIBS) + +fstprune$(EXEEXT): $(fstprune_OBJECTS) $(fstprune_DEPENDENCIES) $(EXTRA_fstprune_DEPENDENCIES) + @rm -f fstprune$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstprune_OBJECTS) $(fstprune_LDADD) $(LIBS) + +fstpush$(EXEEXT): $(fstpush_OBJECTS) $(fstpush_DEPENDENCIES) $(EXTRA_fstpush_DEPENDENCIES) + @rm -f fstpush$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstpush_OBJECTS) $(fstpush_LDADD) $(LIBS) + +fstrandgen$(EXEEXT): $(fstrandgen_OBJECTS) $(fstrandgen_DEPENDENCIES) $(EXTRA_fstrandgen_DEPENDENCIES) + @rm -f fstrandgen$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstrandgen_OBJECTS) $(fstrandgen_LDADD) $(LIBS) + +fstrelabel$(EXEEXT): $(fstrelabel_OBJECTS) $(fstrelabel_DEPENDENCIES) $(EXTRA_fstrelabel_DEPENDENCIES) + @rm -f fstrelabel$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstrelabel_OBJECTS) $(fstrelabel_LDADD) $(LIBS) + +fstreplace$(EXEEXT): $(fstreplace_OBJECTS) $(fstreplace_DEPENDENCIES) $(EXTRA_fstreplace_DEPENDENCIES) + @rm -f fstreplace$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstreplace_OBJECTS) $(fstreplace_LDADD) $(LIBS) + +fstreverse$(EXEEXT): $(fstreverse_OBJECTS) $(fstreverse_DEPENDENCIES) $(EXTRA_fstreverse_DEPENDENCIES) + @rm -f fstreverse$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstreverse_OBJECTS) $(fstreverse_LDADD) $(LIBS) + +fstreweight$(EXEEXT): $(fstreweight_OBJECTS) $(fstreweight_DEPENDENCIES) $(EXTRA_fstreweight_DEPENDENCIES) + @rm -f fstreweight$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstreweight_OBJECTS) $(fstreweight_LDADD) $(LIBS) + +fstrmepsilon$(EXEEXT): $(fstrmepsilon_OBJECTS) $(fstrmepsilon_DEPENDENCIES) $(EXTRA_fstrmepsilon_DEPENDENCIES) + @rm -f fstrmepsilon$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstrmepsilon_OBJECTS) $(fstrmepsilon_LDADD) $(LIBS) + +fstshortestdistance$(EXEEXT): $(fstshortestdistance_OBJECTS) $(fstshortestdistance_DEPENDENCIES) $(EXTRA_fstshortestdistance_DEPENDENCIES) + @rm -f fstshortestdistance$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstshortestdistance_OBJECTS) $(fstshortestdistance_LDADD) $(LIBS) + +fstshortestpath$(EXEEXT): $(fstshortestpath_OBJECTS) $(fstshortestpath_DEPENDENCIES) $(EXTRA_fstshortestpath_DEPENDENCIES) + @rm -f fstshortestpath$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstshortestpath_OBJECTS) $(fstshortestpath_LDADD) $(LIBS) + +fstsymbols$(EXEEXT): $(fstsymbols_OBJECTS) $(fstsymbols_DEPENDENCIES) $(EXTRA_fstsymbols_DEPENDENCIES) + @rm -f fstsymbols$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstsymbols_OBJECTS) $(fstsymbols_LDADD) $(LIBS) + +fstsynchronize$(EXEEXT): $(fstsynchronize_OBJECTS) $(fstsynchronize_DEPENDENCIES) $(EXTRA_fstsynchronize_DEPENDENCIES) + @rm -f fstsynchronize$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstsynchronize_OBJECTS) $(fstsynchronize_LDADD) $(LIBS) + +fsttopsort$(EXEEXT): $(fsttopsort_OBJECTS) $(fsttopsort_DEPENDENCIES) $(EXTRA_fsttopsort_DEPENDENCIES) + @rm -f fsttopsort$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fsttopsort_OBJECTS) $(fsttopsort_LDADD) $(LIBS) + +fstunion$(EXEEXT): $(fstunion_OBJECTS) $(fstunion_DEPENDENCIES) $(EXTRA_fstunion_DEPENDENCIES) + @rm -f fstunion$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstunion_OBJECTS) $(fstunion_LDADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstarcsort-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstarcsort.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstclosure-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstclosure.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstcompile-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstcompile.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstcompose-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstcompose.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstconcat-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstconcat.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstconnect-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstconnect.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstconvert-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstconvert.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstdeterminize-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstdeterminize.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstdifference-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstdifference.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstdisambiguate-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstdisambiguate.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstdraw-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstdraw.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstencode-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstencode.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstepsnormalize-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstepsnormalize.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstequal-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstequal.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstequivalent-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstequivalent.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstinfo-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstinfo.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstintersect-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstintersect.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstinvert-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstinvert.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstisomorphic-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstisomorphic.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstmap-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstmap.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstminimize-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstminimize.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstprint-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstprint.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstproject-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstproject.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstprune-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstprune.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstpush-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstpush.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstrandgen-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstrandgen.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstrelabel-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstrelabel.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstreplace-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstreplace.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstreverse-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstreverse.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstreweight-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstreweight.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstrmepsilon-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstrmepsilon.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstshortestdistance-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstshortestdistance.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstshortestpath-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstshortestpath.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstsymbols-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstsymbols.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstsynchronize-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstsynchronize.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fsttopsort-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fsttopsort.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstunion-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstunion.Po@am__quote@ + +.cc.o: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $< + +.cc.obj: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cc.lo: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ +@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $< + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-am +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-am + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscopelist: cscopelist-am + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(PROGRAMS) +installdirs: + for dir in "$(DESTDIR)$(bindir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-binPROGRAMS clean-generic clean-libtool mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: install-binPROGRAMS + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-binPROGRAMS + +.MAKE: install-am install-strip + +.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \ + clean-binPROGRAMS clean-generic clean-libtool cscopelist-am \ + ctags ctags-am distclean distclean-compile distclean-generic \ + distclean-libtool distclean-tags distdir dvi dvi-am html \ + html-am info info-am install install-am install-binPROGRAMS \ + install-data install-data-am install-dvi install-dvi-am \ + install-exec install-exec-am install-html install-html-am \ + install-info install-info-am install-man install-pdf \ + install-pdf-am install-ps install-ps-am install-strip \ + installcheck installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-compile \ + mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ + tags tags-am uninstall uninstall-am uninstall-binPROGRAMS + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstarcsort-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstarcsort-main.cc new file mode 100644 index 0000000000..b1a67ca212 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstarcsort-main.cc @@ -0,0 +1,51 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Sorts arcs of an FST. + +#include + +#include +#include + +#include +#include +#include +#include + +DECLARE_string(sort_type); + +int fstarcsort_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::MutableFstClass; + + string usage = "Sorts arcs of an FST.\n\n Usage: "; + usage += argv[0]; + usage += " [in.fst [out.fst]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = + (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr fst(MutableFstClass::Read(in_name, true)); + if (!fst) return 1; + + s::ArcSortType sort_type; + if (!s::GetArcSortType(FLAGS_sort_type, &sort_type)) { + LOG(ERROR) << argv[0] << ": Unknown or unsupported sort type: " + << FLAGS_sort_type; + return 1; + } + + s::ArcSort(fst.get(), sort_type); + + return !fst->Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstarcsort.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstarcsort.cc new file mode 100644 index 0000000000..9d7cf2ecba --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstarcsort.cc @@ -0,0 +1,12 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +DEFINE_string(sort_type, "ilabel", + "Comparison method, one of: \"ilabel\", \"olabel\""); + +int fstarcsort_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstarcsort_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstclosure-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstclosure-main.cc new file mode 100644 index 0000000000..4743a0bac0 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstclosure-main.cc @@ -0,0 +1,41 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Creates the Kleene closure of an FST. + +#include + +#include +#include + +#include +#include +#include + +DECLARE_bool(closure_plus); + +int fstclosure_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::MutableFstClass; + + string usage = "Creates the Kleene closure of an FST.\n\n Usage: "; + usage += argv[0]; + usage += " [in.fst [out.fst]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr fst(MutableFstClass::Read(in_name, true)); + if (!fst) return 1; + + s::Closure(fst.get(), s::GetClosureType(FLAGS_closure_plus)); + + return !fst->Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstclosure.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstclosure.cc new file mode 100644 index 0000000000..fb3c22f694 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstclosure.cc @@ -0,0 +1,11 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +DEFINE_bool(closure_plus, false, + "Do not add the empty path (T+ instead of T*)?"); + +int fstclosure_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstclosure_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstcompile-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstcompile-main.cc new file mode 100644 index 0000000000..99c5009a92 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstcompile-main.cc @@ -0,0 +1,84 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Creates binary FSTs from simple text format used by AT&T. + +#include + +#include +#include +#include +#include + +#include +#include +#include + +DECLARE_bool(acceptor); +DECLARE_string(arc_type); +DECLARE_string(fst_type); +DECLARE_string(isymbols); +DECLARE_string(osymbols); +DECLARE_string(ssymbols); +DECLARE_bool(keep_isymbols); +DECLARE_bool(keep_osymbols); +DECLARE_bool(keep_state_numbering); +DECLARE_bool(allow_negative_labels); + +int fstcompile_main(int argc, char **argv) { + namespace s = fst::script; + using fst::SymbolTable; + using fst::SymbolTableTextOptions; + + string usage = "Creates binary FSTs from simple text format.\n\n Usage: "; + usage += argv[0]; + usage += " [text.fst [binary.fst]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + string source = "standard input"; + std::ifstream fstrm; + if (argc > 1 && strcmp(argv[1], "-") != 0) { + fstrm.open(argv[1]); + if (!fstrm) { + LOG(ERROR) << argv[0] << ": Open failed, file = " << argv[1]; + return 1; + } + source = argv[1]; + } + std::istream &istrm = fstrm.is_open() ? fstrm : std::cin; + + const SymbolTableTextOptions opts(FLAGS_allow_negative_labels); + + std::unique_ptr isyms; + if (!FLAGS_isymbols.empty()) { + isyms.reset(SymbolTable::ReadText(FLAGS_isymbols, opts)); + if (!isyms) return 1; + } + + std::unique_ptr osyms; + if (!FLAGS_osymbols.empty()) { + osyms.reset(SymbolTable::ReadText(FLAGS_osymbols, opts)); + if (!osyms) return 1; + } + + std::unique_ptr ssyms; + if (!FLAGS_ssymbols.empty()) { + ssyms.reset(SymbolTable::ReadText(FLAGS_ssymbols)); + if (!ssyms) return 1; + } + + const string dest = argc > 2 ? argv[2] : ""; + + s::CompileFst(istrm, source, dest, FLAGS_fst_type, FLAGS_arc_type, + isyms.get(), osyms.get(), ssyms.get(), FLAGS_acceptor, + FLAGS_keep_isymbols, FLAGS_keep_osymbols, + FLAGS_keep_state_numbering, FLAGS_allow_negative_labels); + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstcompile.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstcompile.cc new file mode 100644 index 0000000000..9b758b6dcf --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstcompile.cc @@ -0,0 +1,20 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +DEFINE_bool(acceptor, false, "Input in acceptor format"); +DEFINE_string(arc_type, "standard", "Output arc type"); +DEFINE_string(fst_type, "vector", "Output FST type"); +DEFINE_string(isymbols, "", "Input label symbol table"); +DEFINE_string(osymbols, "", "Output label symbol table"); +DEFINE_string(ssymbols, "", "State label symbol table"); +DEFINE_bool(keep_isymbols, false, "Store input label symbol table with FST"); +DEFINE_bool(keep_osymbols, false, "Store output label symbol table with FST"); +DEFINE_bool(keep_state_numbering, false, "Do not renumber input states"); +DEFINE_bool(allow_negative_labels, false, + "Allow negative labels (not recommended; may cause conflicts)"); + +int fstcompile_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstcompile_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstcompose-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstcompose-main.cc new file mode 100644 index 0000000000..df5afd72eb --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstcompose-main.cc @@ -0,0 +1,72 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Composes two FSTs. + +#include + +#include +#include + +#include +#include +#include +#include + +DECLARE_string(compose_filter); +DECLARE_bool(connect); + +int fstcompose_main(int argc, char **argv) { + namespace s = fst::script; + using fst::ComposeFilter; + using fst::ComposeOptions; + using fst::script::FstClass; + using fst::script::VectorFstClass; + + string usage = "Composes two FSTs.\n\n Usage: "; + usage += argv[0]; + usage += " in1.fst in2.fst [out.fst]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc < 3 || argc > 4) { + ShowUsage(); + return 1; + } + + const string in1_name = strcmp(argv[1], "-") != 0 ? argv[1] : ""; + const string in2_name = + (argc > 2 && (strcmp(argv[2], "-") != 0)) ? argv[2] : ""; + const string out_name = argc > 3 ? argv[3] : ""; + + if (in1_name.empty() && in2_name.empty()) { + LOG(ERROR) << argv[0] << ": Can't take both inputs from standard input"; + return 1; + } + + std::unique_ptr ifst1(FstClass::Read(in1_name)); + if (!ifst1) return 1; + + std::unique_ptr ifst2(FstClass::Read(in2_name)); + if (!ifst2) return 1; + + if (ifst1->ArcType() != ifst2->ArcType()) { + LOG(ERROR) << argv[0] << ": Input FSTs must have the same arc type"; + return 1; + } + + VectorFstClass ofst(ifst1->ArcType()); + + ComposeFilter compose_filter; + if (!s::GetComposeFilter(FLAGS_compose_filter, &compose_filter)) { + LOG(ERROR) << argv[0] << ": Unknown or unsupported compose filter type: " + << FLAGS_compose_filter; + return 1; + } + + const ComposeOptions opts(FLAGS_connect, compose_filter); + + s::Compose(*ifst1, *ifst2, &ofst, opts); + + return !ofst.Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstcompose.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstcompose.cc new file mode 100644 index 0000000000..8b1348fcd7 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstcompose.cc @@ -0,0 +1,13 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +DEFINE_string(compose_filter, "auto", + "Composition filter, one of: \"alt_sequence\", \"auto\", " + "\"match\", \"null\", \"sequence\", \"trivial\""); +DEFINE_bool(connect, true, "Trim output"); + +int fstcompose_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstcompose_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstconcat-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstconcat-main.cc new file mode 100644 index 0000000000..07609ec944 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstconcat-main.cc @@ -0,0 +1,49 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Concatenates two FSTs. + +#include + +#include +#include + +#include +#include +#include + +int fstconcat_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + using fst::script::MutableFstClass; + + string usage = "Concatenates two FSTs.\n\n Usage: "; + usage += argv[0]; + usage += " in1.fst in2.fst [out.fst]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc < 3 || argc > 4) { + ShowUsage(); + return 1; + } + + const string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1]; + const string in2_name = strcmp(argv[2], "-") == 0 ? "" : argv[2]; + const string out_name = argc > 3 ? argv[3] : ""; + + if (in1_name.empty() && in2_name.empty()) { + LOG(ERROR) << argv[0] << ": Can't take both inputs from standard input"; + return 1; + } + + std::unique_ptr fst1(MutableFstClass::Read(in1_name, true)); + if (!fst1) return 1; + + std::unique_ptr fst2(FstClass::Read(in2_name)); + if (!fst2) return 1; + + s::Concat(fst1.get(), *fst2); + + return !fst1->Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstconcat.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstconcat.cc new file mode 100644 index 0000000000..68ce58c70e --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstconcat.cc @@ -0,0 +1,6 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +int fstconcat_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstconcat_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstconnect-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstconnect-main.cc new file mode 100644 index 0000000000..6de987dfcf --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstconnect-main.cc @@ -0,0 +1,40 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Removes useless (inaccessible or non-coaccessible) states and arcs from an +// FST. + +#include + +#include +#include + +#include +#include + +int fstconnect_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + using fst::script::MutableFstClass; + + string usage = "Removes useless states and arcs from an FST.\n\n Usage: "; + usage += argv[0]; + usage += " [in.fst [out.fst]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr fst(MutableFstClass::Read(in_name, true)); + if (!fst) return 1; + + s::Connect(fst.get()); + + return !fst->Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstconnect.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstconnect.cc new file mode 100644 index 0000000000..c31a3574a2 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstconnect.cc @@ -0,0 +1,6 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +int fstconnect_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstconnect_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstconvert-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstconvert-main.cc new file mode 100644 index 0000000000..60dc7aba62 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstconvert-main.cc @@ -0,0 +1,44 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Converts an FST to another type. + +#include + +#include +#include + +#include +#include + +DECLARE_string(fst_type); + +int fstconvert_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + + string usage = "Converts an FST to another type.\n\n Usage: "; + usage += argv[0]; + usage += " [in.fst [out.fst]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr ifst(FstClass::Read(in_name)); + if (!ifst) return 1; + + if (ifst->FstType() != FLAGS_fst_type) { + std::unique_ptr ofst(s::Convert(*ifst, FLAGS_fst_type)); + if (!ofst) return 1; + return !ofst->Write(out_name); + } else { + return !ifst->Write(out_name); + } +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstconvert.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstconvert.cc new file mode 100644 index 0000000000..331977abf4 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstconvert.cc @@ -0,0 +1,10 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +DEFINE_string(fst_type, "vector", "Output FST type"); + +int fstconvert_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstconvert_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdeterminize-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdeterminize-main.cc new file mode 100644 index 0000000000..53e3e1d236 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdeterminize-main.cc @@ -0,0 +1,66 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Determinizes an FST. + +#include + +#include +#include + +#include +#include +#include + +DECLARE_double(delta); +DECLARE_string(weight); +DECLARE_int64(nstate); +DECLARE_int64(subsequential_label); +DECLARE_string(det_type); +DECLARE_bool(increment_subsequential_label); + +int fstdeterminize_main(int argc, char **argv) { + namespace s = fst::script; + using fst::DeterminizeType; + using fst::script::FstClass; + using fst::script::VectorFstClass; + using fst::script::WeightClass; + + string usage = "Determinizes an FST.\n\n Usage: "; + usage += argv[0]; + usage += " [in.fst [out.fst]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + DeterminizeType det_type; + if (!s::GetDeterminizeType(FLAGS_det_type, &det_type)) { + LOG(ERROR) << argv[0] << ": Unknown or unsupported determinization type: " + << FLAGS_det_type; + return 1; + } + + const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr ifst(FstClass::Read(in_name)); + if (!ifst) return 1; + + VectorFstClass ofst(ifst->ArcType()); + + const auto weight_threshold = + FLAGS_weight.empty() ? WeightClass::Zero(ifst->WeightType()) + : WeightClass(ifst->WeightType(), FLAGS_weight); + + const s::DeterminizeOptions opts(FLAGS_delta, weight_threshold, FLAGS_nstate, + FLAGS_subsequential_label, det_type, + FLAGS_increment_subsequential_label); + + s::Determinize(*ifst, &ofst, opts); + + return !ofst.Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdeterminize.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdeterminize.cc new file mode 100644 index 0000000000..613522bef3 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdeterminize.cc @@ -0,0 +1,23 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +DEFINE_double(delta, fst::kDelta, "Comparison/quantization delta"); +DEFINE_string(weight, "", "Weight threshold"); +DEFINE_int64(nstate, fst::kNoStateId, "State number threshold"); +DEFINE_int64(subsequential_label, 0, + "Input label of arc corresponding to residual final output when" + " producing a subsequential transducer"); +DEFINE_string(det_type, "functional", + "Type of determinization: \"functional\", " + "\"nonfunctional\", \"disambiguate\""); +DEFINE_bool(increment_subsequential_label, false, + "Increment subsequential_label to obtain distinct labels for " + " subsequential arcs at a given state"); + +int fstdeterminize_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstdeterminize_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdifference-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdifference-main.cc new file mode 100644 index 0000000000..82a70d50c5 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdifference-main.cc @@ -0,0 +1,66 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Subtracts an unweighted DFA from an FSA. + +#include + +#include +#include + +#include +#include +#include +#include + +DECLARE_string(compose_filter); +DECLARE_bool(connect); + +int fstdifference_main(int argc, char **argv) { + namespace s = fst::script; + using fst::ComposeFilter; + using fst::DifferenceOptions; + using fst::script::FstClass; + using fst::script::VectorFstClass; + + string usage = "Subtracts an unweighted DFA from an FSA.\n\n Usage: "; + usage += argv[0]; + usage += " in1.fst in2.fst [out.fst]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc < 3 || argc > 4) { + ShowUsage(); + return 1; + } + + const string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1]; + const string in2_name = strcmp(argv[2], "-") == 0 ? "" : argv[2]; + const string out_name = argc > 3 ? argv[3] : ""; + + if (in1_name.empty() && in2_name.empty()) { + LOG(ERROR) << argv[0] << ": Can't take both inputs from standard input"; + return 1; + } + + std::unique_ptr ifst1(FstClass::Read(in1_name)); + if (!ifst1) return 1; + + std::unique_ptr ifst2(FstClass::Read(in2_name)); + if (!ifst2) return 1; + + VectorFstClass ofst(ifst1->ArcType()); + + ComposeFilter compose_filter; + if (!s::GetComposeFilter(FLAGS_compose_filter, &compose_filter)) { + LOG(ERROR) << argv[0] << ": Unknown or unsupported compose filter type: " + << FLAGS_compose_filter; + return 1; + } + + const DifferenceOptions opts(FLAGS_connect, compose_filter); + + s::Difference(*ifst1, *ifst2, &ofst, opts); + + return !ofst.Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdifference.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdifference.cc new file mode 100644 index 0000000000..2086bbfc2f --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdifference.cc @@ -0,0 +1,13 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +DEFINE_string(compose_filter, "auto", + "Composition filter, one of: \"alt_sequence\", \"auto\", " + "\"match\", \"null\", \"sequence\", \"trivial\""); +DEFINE_bool(connect, true, "Trim output"); + +int fstdifference_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstdifference_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdisambiguate-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdisambiguate-main.cc new file mode 100644 index 0000000000..b906af32fe --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdisambiguate-main.cc @@ -0,0 +1,54 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Disambiguates an FST. + +#include + +#include +#include + +#include +#include + +DECLARE_double(delta); +DECLARE_int64(nstate); +DECLARE_string(weight); +DECLARE_int64(subsequential_label); + +int fstdisambiguate_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + using fst::script::VectorFstClass; + using fst::script::WeightClass; + + string usage = "Disambiguates an FST.\n\n Usage: "; + usage += argv[0]; + usage += " [in.fst [out.fst]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr ifst(FstClass::Read(in_name)); + if (!ifst) return 1; + + VectorFstClass ofst(ifst->ArcType()); + + const auto weight_threshold = + FLAGS_weight.empty() ? WeightClass::Zero(ifst->WeightType()) + : WeightClass(ifst->WeightType(), FLAGS_weight); + + const s::DisambiguateOptions opts(FLAGS_delta, weight_threshold, FLAGS_nstate, + FLAGS_subsequential_label); + + s::Disambiguate(*ifst, &ofst, opts); + + return !ofst.Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdisambiguate.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdisambiguate.cc new file mode 100644 index 0000000000..9aa13f3d24 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdisambiguate.cc @@ -0,0 +1,17 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +DEFINE_double(delta, fst::kDelta, "Comparison/quantization delta"); +DEFINE_int64(nstate, fst::kNoStateId, "State number threshold"); +DEFINE_string(weight, "", "Weight threshold"); +DEFINE_int64(subsequential_label, 0, + "Input label of arc corresponding to residual final output when" + " producing a subsequential transducer"); + +int fstdisambiguate_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstdisambiguate_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdraw-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdraw-main.cc new file mode 100644 index 0000000000..d28299e5d9 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdraw-main.cc @@ -0,0 +1,104 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Draws a binary FSTs in the Graphviz dot text format. + +#include + +#include +#include +#include +#include + +#include +#include +#include + +DECLARE_bool(acceptor); +DECLARE_string(isymbols); +DECLARE_string(osymbols); +DECLARE_string(ssymbols); +DECLARE_bool(numeric); +DECLARE_int32(precision); +DECLARE_string(float_format); +DECLARE_bool(show_weight_one); +DECLARE_string(title); +DECLARE_bool(portrait); +DECLARE_bool(vertical); +DECLARE_int32(fontsize); +DECLARE_double(height); +DECLARE_double(width); +DECLARE_double(nodesep); +DECLARE_double(ranksep); +DECLARE_bool(allow_negative_labels); + +int fstdraw_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + using fst::SymbolTable; + using fst::SymbolTableTextOptions; + + string usage = "Prints out binary FSTs in dot text format.\n\n Usage: "; + usage += argv[0]; + usage += " [binary.fst [text.dot]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; + + std::unique_ptr fst(FstClass::Read(in_name)); + if (!fst) return 1; + + string dest = "stdout"; + std::ofstream fstrm; + if (argc == 3) { + fstrm.open(argv[2]); + if (!fstrm) { + LOG(ERROR) << argv[0] << ": Open failed, file = " << argv[2]; + return 1; + } + dest = argv[2]; + } + std::ostream &ostrm = fstrm.is_open() ? fstrm : std::cout; + + const SymbolTableTextOptions opts(FLAGS_allow_negative_labels); + + std::unique_ptr isyms; + if (!FLAGS_isymbols.empty() && !FLAGS_numeric) { + isyms.reset(SymbolTable::ReadText(FLAGS_isymbols, opts)); + if (!isyms) return 1; + } + + std::unique_ptr osyms; + if (!FLAGS_osymbols.empty() && !FLAGS_numeric) { + osyms.reset(SymbolTable::ReadText(FLAGS_osymbols, opts)); + if (!osyms) return 1; + } + + std::unique_ptr ssyms; + if (!FLAGS_ssymbols.empty() && !FLAGS_numeric) { + ssyms.reset(SymbolTable::ReadText(FLAGS_ssymbols)); + if (!ssyms) return 1; + } + + if (!isyms && !FLAGS_numeric && fst->InputSymbols()) { + isyms.reset(fst->InputSymbols()->Copy()); + } + + if (!osyms && !FLAGS_numeric && fst->OutputSymbols()) { + osyms.reset(fst->OutputSymbols()->Copy()); + } + + s::DrawFst(*fst, isyms.get(), osyms.get(), ssyms.get(), FLAGS_acceptor, + FLAGS_title, FLAGS_width, FLAGS_height, FLAGS_portrait, + FLAGS_vertical, FLAGS_ranksep, FLAGS_nodesep, FLAGS_fontsize, + FLAGS_precision, FLAGS_float_format, FLAGS_show_weight_one, + &ostrm, dest); + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdraw.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdraw.cc new file mode 100644 index 0000000000..69f6fb8ba9 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstdraw.cc @@ -0,0 +1,31 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +DEFINE_bool(acceptor, false, "Input in acceptor format"); +DEFINE_string(isymbols, "", "Input label symbol table"); +DEFINE_string(osymbols, "", "Output label symbol table"); +DEFINE_string(ssymbols, "", "State label symbol table"); +DEFINE_bool(numeric, false, "Print numeric labels"); +DEFINE_int32(precision, 5, "Set precision (number of char/float)"); +DEFINE_string(float_format, "g", + "Floating-point format, one of: \"e\", \"f\", or \"g\""); +DEFINE_bool(show_weight_one, false, + "Print/draw arc weights and final weights equal to Weight::One()"); +DEFINE_string(title, "", "Set figure title"); +DEFINE_bool(portrait, false, "Portrait mode (def: landscape)"); +DEFINE_bool(vertical, false, "Draw bottom-to-top instead of left-to-right"); +DEFINE_int32(fontsize, 14, "Set fontsize"); +DEFINE_double(height, 11, "Set height"); +DEFINE_double(width, 8.5, "Set width"); +DEFINE_double(nodesep, 0.25, + "Set minimum separation between nodes (see dot documentation)"); +DEFINE_double(ranksep, 0.40, + "Set minimum separation between ranks (see dot documentation)"); +DEFINE_bool(allow_negative_labels, false, + "Allow negative labels (not recommended; may cause conflicts)"); + +int fstdraw_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstdraw_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstencode-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstencode-main.cc new file mode 100644 index 0000000000..944148016a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstencode-main.cc @@ -0,0 +1,53 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Encode transducer labels and/or weights. + +#include + +#include +#include + +#include +#include +#include +#include + +DECLARE_bool(encode_labels); +DECLARE_bool(encode_weights); +DECLARE_bool(encode_reuse); +DECLARE_bool(decode); + +int fstencode_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + using fst::script::MutableFstClass; + + string usage = "Encodes transducer labels and/or weights.\n\n Usage: "; + usage += argv[0]; + usage += " in.fst codex [out.fst]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc < 3 || argc > 4) { + ShowUsage(); + return 1; + } + + const string in_name = (strcmp(argv[1], "-") != 0) ? argv[1] : ""; + const string codex_name = argv[2]; + const string out_name = argc > 3 ? argv[3] : ""; + + std::unique_ptr fst(MutableFstClass::Read(in_name, true)); + if (!fst) return 1; + + if (FLAGS_decode) { + s::Decode(fst.get(), codex_name); + return !fst->Write(out_name); + } else { + const auto flags = + s::GetEncodeFlags(FLAGS_encode_labels, FLAGS_encode_weights); + s::Encode(fst.get(), flags, FLAGS_encode_reuse, codex_name); + return !fst->Write(out_name); + } +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstencode.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstencode.cc new file mode 100644 index 0000000000..94c19aaa47 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstencode.cc @@ -0,0 +1,13 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +DEFINE_bool(encode_labels, false, "Encode output labels"); +DEFINE_bool(encode_weights, false, "Encode weights"); +DEFINE_bool(encode_reuse, false, "Re-use existing codex"); +DEFINE_bool(decode, false, "Decode labels and/or weights"); + +int fstencode_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstencode_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstepsnormalize-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstepsnormalize-main.cc new file mode 100644 index 0000000000..acadd17196 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstepsnormalize-main.cc @@ -0,0 +1,44 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Epsilon-normalizes an FST. + +#include + +#include +#include + +#include +#include +#include + +DECLARE_bool(eps_norm_output); + +int fstepsnormalize_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + using fst::script::VectorFstClass; + + string usage = "Epsilon normalizes an FST.\n\n Usage: "; + usage += argv[0]; + usage += " [in.fst [out.fst]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr ifst(FstClass::Read(in_name)); + if (!ifst) return 1; + + VectorFstClass ofst(ifst->ArcType()); + + s::EpsNormalize(*ifst, &ofst, s::GetEpsNormalizeType(FLAGS_eps_norm_output)); + + return !ofst.Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstepsnormalize.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstepsnormalize.cc new file mode 100644 index 0000000000..b8091d544f --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstepsnormalize.cc @@ -0,0 +1,10 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +DEFINE_bool(eps_norm_output, false, "Normalize output epsilons"); + +int fstepsnormalize_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstepsnormalize_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstequal-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstequal-main.cc new file mode 100644 index 0000000000..f7b2248d15 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstequal-main.cc @@ -0,0 +1,50 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Two FSTS are equal iff their exit status is zero. + +#include + +#include +#include + +#include +#include +#include + +DECLARE_double(delta); + +int fstequal_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + + string usage = "Two FSTs are equal iff the exit status is zero.\n\n Usage: "; + usage += argv[0]; + usage += " in1.fst in2.fst\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc != 3) { + ShowUsage(); + return 1; + } + + const string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1]; + const string in2_name = strcmp(argv[2], "-") == 0 ? "" : argv[2]; + + if (in1_name.empty() && in2_name.empty()) { + LOG(ERROR) << argv[0] << ": Can't take both inputs from standard input"; + return 1; + } + + std::unique_ptr ifst1(FstClass::Read(in1_name)); + if (!ifst1) return 1; + + std::unique_ptr ifst2(FstClass::Read(in2_name)); + if (!ifst2) return 1; + + bool result = s::Equal(*ifst1, *ifst2, FLAGS_delta); + if (!result) VLOG(1) << "FSTs are not equal."; + + return result ? 0 : 2; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstequal.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstequal.cc new file mode 100644 index 0000000000..e1212a0a9f --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstequal.cc @@ -0,0 +1,11 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +DEFINE_double(delta, fst::kDelta, "Comparison/quantization delta"); + +int fstequal_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstequal_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstequivalent-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstequivalent-main.cc new file mode 100644 index 0000000000..8b4b151005 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstequivalent-main.cc @@ -0,0 +1,73 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Two DFAs are equivalent iff their exit status is zero. + +#include + +#include +#include + +#include +#include +#include +#include +#include + +DECLARE_double(delta); +DECLARE_bool(random); +DECLARE_int32(max_length); +DECLARE_int32(npath); +DECLARE_int32(seed); +DECLARE_string(select); + +int fstequivalent_main(int argc, char **argv) { + namespace s = fst::script; + using fst::RandGenOptions; + using fst::script::FstClass; + + string usage = + "Two DFAs are equivalent iff the exit status is zero.\n\n" + " Usage: "; + usage += argv[0]; + usage += " in1.fst in2.fst\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc != 3) { + ShowUsage(); + return 1; + } + + const string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1]; + const string in2_name = strcmp(argv[2], "-") == 0 ? "" : argv[2]; + + if (in1_name.empty() && in2_name.empty()) { + LOG(ERROR) << argv[0] << ": Can't take both inputs from standard input"; + return 1; + } + + std::unique_ptr ifst1(FstClass::Read(in1_name)); + if (!ifst1) return 1; + + std::unique_ptr ifst2(FstClass::Read(in2_name)); + if (!ifst2) return 1; + + if (!FLAGS_random) { + bool result = s::Equivalent(*ifst1, *ifst2, FLAGS_delta); + if (!result) VLOG(1) << "FSTs are not equivalent"; + return result ? 0 : 2; + } else { + s::RandArcSelection ras; + if (!s::GetRandArcSelection(FLAGS_select, &ras)) { + LOG(ERROR) << argv[0] << ": Unknown or unsupported select type " + << FLAGS_select; + return 1; + } + const RandGenOptions opts(ras, FLAGS_max_length); + bool result = s::RandEquivalent(*ifst1, *ifst2, FLAGS_npath, FLAGS_delta, + FLAGS_seed, opts); + if (!result) VLOG(1) << "FSTs are not equivalent"; + return result ? 0 : 2; + } +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstequivalent.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstequivalent.cc new file mode 100644 index 0000000000..cfc5b772d3 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstequivalent.cc @@ -0,0 +1,22 @@ +#include + +#include +#include + +#include +#include + +DEFINE_double(delta, fst::kDelta, "Comparison/quantization delta"); +DEFINE_bool(random, false, + "Test equivalence by randomly selecting paths in the input FSTs"); +DEFINE_int32(max_length, INT32_MAX, "Maximum path length"); +DEFINE_int32(npath, 1, "Number of paths to generate"); +DEFINE_int32(seed, time(nullptr) + getpid(), "Random seed"); +DEFINE_string(select, "uniform", + "Selection type: one of: " + " \"uniform\", \"log_prob\" (when appropriate)," + " \"fast_log_prob\" (when appropriate)"); + +int fstequivalent_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstequivalent_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstinfo-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstinfo-main.cc new file mode 100644 index 0000000000..9877e0708b --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstinfo-main.cc @@ -0,0 +1,46 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Prints out various information about an FST such as number of states +// and arcs and property values (see properties.h). + +#include + +#include +#include + +#include +#include + +DECLARE_string(arc_filter); +DECLARE_string(info_type); +DECLARE_bool(pipe); +DECLARE_bool(test_properties); +DECLARE_bool(fst_verify); + +int fstinfo_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + + string usage = "Prints out information about an FST.\n\n Usage: "; + usage += argv[0]; + usage += " [in.fst]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 2) { + ShowUsage(); + return 1; + } + + const string in_name = + (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : ""; + + std::unique_ptr ifst(FstClass::Read(in_name)); + if (!ifst) return 1; + + s::PrintFstInfo(*ifst, FLAGS_test_properties, FLAGS_arc_filter, + FLAGS_info_type, FLAGS_fst_verify, FLAGS_pipe); + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstinfo.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstinfo.cc new file mode 100644 index 0000000000..6d083e8ee7 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstinfo.cc @@ -0,0 +1,20 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +DEFINE_string(arc_filter, "any", + "Arc filter: one of:" + " \"any\", \"epsilon\", \"iepsilon\", \"oepsilon\"; " + "this only affects the counts of (co)accessible states, " + "connected states, and (strongly) connected components"); +DEFINE_string(info_type, "auto", + "Info format: one of: \"auto\", \"long\", \"short\""); +DEFINE_bool(pipe, false, "Send info to stderr, input to stdout"); +DEFINE_bool(test_properties, true, + "Compute property values (if unknown to FST)"); +DEFINE_bool(fst_verify, true, "Verify FST sanity"); + +int fstinfo_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstinfo_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstintersect-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstintersect-main.cc new file mode 100644 index 0000000000..9d1c9a3ef8 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstintersect-main.cc @@ -0,0 +1,65 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Intersects two FSTs. + +#include + +#include +#include + +#include +#include +#include +#include + +DECLARE_string(compose_filter); +DECLARE_bool(connect); + +int fstintersect_main(int argc, char **argv) { + namespace s = fst::script; + using fst::ComposeFilter; + using fst::script::FstClass; + using fst::script::VectorFstClass; + + string usage = "Intersects two FSAs.\n\n Usage: "; + usage += argv[0]; + usage += " in1.fst in2.fst [out.fst]\n"; + usage += " Flags: connect\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc < 3 || argc > 4) { + ShowUsage(); + return 1; + } + + const string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1]; + const string in2_name = strcmp(argv[2], "-") == 0 ? "" : argv[2]; + const string out_name = argc > 3 ? argv[3] : ""; + + if (in1_name.empty() && in2_name.empty()) { + LOG(ERROR) << argv[0] << ": Can't take both inputs from standard input"; + return 1; + } + + std::unique_ptr ifst1(FstClass::Read(in1_name)); + if (!ifst1) return 1; + std::unique_ptr ifst2(FstClass::Read(in2_name)); + if (!ifst2) return 1; + + VectorFstClass ofst(ifst1->ArcType()); + + ComposeFilter compose_filter; + if (!s::GetComposeFilter(FLAGS_compose_filter, &compose_filter)) { + LOG(ERROR) << argv[0] << ": Unknown or unsupported compose filter type: " + << FLAGS_compose_filter; + return 1; + } + + const fst::IntersectOptions opts(FLAGS_connect, compose_filter); + + s::Intersect(*ifst1, *ifst2, &ofst, opts); + + return !ofst.Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstintersect.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstintersect.cc new file mode 100644 index 0000000000..802cc1ced4 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstintersect.cc @@ -0,0 +1,13 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +DEFINE_string(compose_filter, "auto", + "Composition filter, one of: \"alt_sequence\", \"auto\", " + "\"match\", \"null\", \"sequence\", \"trivial\""); +DEFINE_bool(connect, true, "Trim output"); + +int fstintersect_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstintersect_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstinvert-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstinvert-main.cc new file mode 100644 index 0000000000..61e858a1ea --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstinvert-main.cc @@ -0,0 +1,38 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Inverts a transduction. + +#include + +#include +#include + +#include +#include + +int fstinvert_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::MutableFstClass; + + string usage = "Inverts a transduction.\n\n Usage: "; + usage += argv[0]; + usage += " [in.fst [out.fst]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr fst(MutableFstClass::Read(in_name, true)); + if (!fst) return 1; + + s::Invert(fst.get()); + + return !fst->Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstinvert.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstinvert.cc new file mode 100644 index 0000000000..3ead13cf51 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstinvert.cc @@ -0,0 +1,6 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +int fstinvert_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstinvert_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstisomorphic-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstisomorphic-main.cc new file mode 100644 index 0000000000..2b7c6bf47c --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstisomorphic-main.cc @@ -0,0 +1,53 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Two FSTS are isomorphic (equal up to state and arc re-ordering) iff their +// exit status is zero. FSTs should be deterministic when viewed as unweighted +// automata. + +#include + +#include +#include + +#include +#include +#include + +DECLARE_double(delta); + +int fstisomorphic_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + + string usage = + "Two FSTs are isomorphic iff the exit status is zero.\n\n Usage: "; + usage += argv[0]; + usage += " in1.fst in2.fst\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc != 3) { + ShowUsage(); + return 1; + } + + const string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1]; + const string in2_name = strcmp(argv[2], "-") == 0 ? "" : argv[2]; + + if (in1_name.empty() && in2_name.empty()) { + LOG(ERROR) << argv[0] << ": Can't take both inputs from standard input"; + return 1; + } + + std::unique_ptr ifst1(FstClass::Read(in1_name)); + if (!ifst1) return 1; + + std::unique_ptr ifst2(FstClass::Read(in2_name)); + if (!ifst2) return 1; + + bool result = s::Isomorphic(*ifst1, *ifst2, FLAGS_delta); + if (!result) VLOG(1) << "FSTs are not isomorphic"; + + return result ? 0 : 2; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstisomorphic.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstisomorphic.cc new file mode 100644 index 0000000000..bb32962bb2 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstisomorphic.cc @@ -0,0 +1,11 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +DEFINE_double(delta, fst::kDelta, "Comparison/quantization delta"); + +int fstisomorphic_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstisomorphic_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstmap-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstmap-main.cc new file mode 100644 index 0000000000..56a8198e79 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstmap-main.cc @@ -0,0 +1,60 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Applies an operation to each arc of an FST. + +#include + +#include +#include + +#include +#include +#include +#include + +DECLARE_double(delta); +DECLARE_string(map_type); +DECLARE_double(power); +DECLARE_string(weight); + +int fstmap_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + using fst::script::WeightClass; + + string usage = "Applies an operation to each arc of an FST.\n\n Usage: "; + usage += argv[0]; + usage += " [in.fst [out.fst]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr ifst(FstClass::Read(in_name)); + if (!ifst) return 1; + + s::MapType map_type; + if (!s::GetMapType(FLAGS_map_type, &map_type)) { + LOG(ERROR) << argv[0] << ": Unknown or unsupported map type " + << FLAGS_map_type; + return 1; + } + + const auto weight_param = + !FLAGS_weight.empty() + ? WeightClass(ifst->WeightType(), FLAGS_weight) + : (FLAGS_map_type == "times" ? WeightClass::One(ifst->WeightType()) + : WeightClass::Zero(ifst->WeightType())); + + std::unique_ptr ofst( + s::Map(*ifst, map_type, FLAGS_delta, FLAGS_power, weight_param)); + + return !ofst->Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstmap.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstmap.cc new file mode 100644 index 0000000000..cf8ddcae5a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstmap.cc @@ -0,0 +1,20 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +DEFINE_double(delta, fst::kDelta, "Comparison/quantization delta"); +DEFINE_string(map_type, "identity", + "Map operation, one of: \"arc_sum\", \"arc_unique\", " + "\"float_power\" (--power)\", \"identity\", \"input_epsilon\", " + "\"invert\", \"output_epsilon\", \"plus (--weight)\", " + "\"quantize (--delta)\", \"rmweight\", \"superfinal\", " + "\"power (--power)\", \"times (--weight)\", \"to_log\", " + "\"to_log64\", \"to_std\""); +DEFINE_double(power, 1.0, "Power parameter"); +DEFINE_string(weight, "", "Weight parameter"); + +int fstmap_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstmap_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstminimize-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstminimize-main.cc new file mode 100644 index 0000000000..f189f94b87 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstminimize-main.cc @@ -0,0 +1,57 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Minimizes a deterministic FST. + +#include + +#include +#include + +#include +#include +#include + +DECLARE_double(delta); +DECLARE_bool(allow_nondet); + +int fstminimize_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::MutableFstClass; + using fst::script::VectorFstClass; + + string usage = "Minimizes a deterministic FST.\n\n Usage: "; + usage += argv[0]; + usage += " [in.fst [out1.fst [out2.fst]]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 4) { + ShowUsage(); + return 1; + } + + const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; + const string out1_name = + (argc > 2 && strcmp(argv[2], "-") != 0) ? argv[2] : ""; + const string out2_name = + (argc > 3 && strcmp(argv[3], "-") != 0) ? argv[3] : ""; + + if (out1_name.empty() && out2_name.empty() && argc > 3) { + LOG(ERROR) << argv[0] << ": Both outputs can't be standard output."; + return 1; + } + + std::unique_ptr fst1(MutableFstClass::Read(in_name, true)); + if (!fst1) return 1; + + if (argc > 3) { + std::unique_ptr fst2(new VectorFstClass(fst1->ArcType())); + s::Minimize(fst1.get(), fst2.get(), FLAGS_delta, FLAGS_allow_nondet); + if (!fst2->Write(out2_name)) return 1; + } else { + s::Minimize(fst1.get(), nullptr, FLAGS_delta, FLAGS_allow_nondet); + } + + return !fst1->Write(out1_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstminimize.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstminimize.cc new file mode 100644 index 0000000000..ef602f7652 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstminimize.cc @@ -0,0 +1,13 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +DEFINE_double(delta, fst::kShortestDelta, "Comparison/quantization delta"); +DEFINE_bool(allow_nondet, false, "Minimize non-deterministic FSTs"); + +int fstminimize_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstminimize_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstprint-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstprint-main.cc new file mode 100644 index 0000000000..95884ddb71 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstprint-main.cc @@ -0,0 +1,104 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Prints out binary FSTs in simple text format used by AT&T. + +#include + +#include +#include +#include +#include + +#include +#include +#include + +DECLARE_bool(acceptor); +DECLARE_string(isymbols); +DECLARE_string(osymbols); +DECLARE_string(ssymbols); +DECLARE_bool(numeric); +DECLARE_string(save_isymbols); +DECLARE_string(save_osymbols); +DECLARE_bool(show_weight_one); +DECLARE_bool(allow_negative_labels); +DECLARE_string(missing_symbol); + +int fstprint_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + using fst::SymbolTable; + using fst::SymbolTableTextOptions; + + string usage = "Prints out binary FSTs in simple text format.\n\n Usage: "; + usage += argv[0]; + usage += " [binary.fst [text.fst]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr fst(FstClass::Read(in_name)); + if (!fst) return 1; + + string dest = "standard output"; + std::ofstream fstrm; + if (argc == 3) { + fstrm.open(argv[2]); + if (!fstrm) { + LOG(ERROR) << argv[0] << ": Open failed, file = " << argv[2]; + return 1; + } + dest = argv[2]; + } + std::ostream &ostrm = fstrm.is_open() ? fstrm : std::cout; + ostrm.precision(9); + + const SymbolTableTextOptions opts(FLAGS_allow_negative_labels); + + std::unique_ptr isyms; + if (!FLAGS_isymbols.empty() && !FLAGS_numeric) { + isyms.reset(SymbolTable::ReadText(FLAGS_isymbols, opts)); + if (!isyms) return 1; + } + + std::unique_ptr osyms; + if (!FLAGS_osymbols.empty() && !FLAGS_numeric) { + osyms.reset(SymbolTable::ReadText(FLAGS_osymbols, opts)); + if (!osyms) return 1; + } + + std::unique_ptr ssyms; + if (!FLAGS_ssymbols.empty() && !FLAGS_numeric) { + ssyms.reset(SymbolTable::ReadText(FLAGS_ssymbols)); + if (!ssyms) return 1; + } + + if (!isyms && !FLAGS_numeric && fst->InputSymbols()) { + isyms.reset(fst->InputSymbols()->Copy()); + } + + if (!osyms && !FLAGS_numeric && fst->OutputSymbols()) { + osyms.reset(fst->OutputSymbols()->Copy()); + } + + s::PrintFst(*fst, ostrm, dest, isyms.get(), osyms.get(), ssyms.get(), + FLAGS_acceptor, FLAGS_show_weight_one, FLAGS_missing_symbol); + + if (isyms && !FLAGS_save_isymbols.empty()) { + if (!isyms->WriteText(FLAGS_save_isymbols)) return 1; + } + + if (osyms && !FLAGS_save_osymbols.empty()) { + if (!osyms->WriteText(FLAGS_save_osymbols)) return 1; + } + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstprint.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstprint.cc new file mode 100644 index 0000000000..8f4272780e --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstprint.cc @@ -0,0 +1,22 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +DEFINE_bool(acceptor, false, "Input in acceptor format?"); +DEFINE_string(isymbols, "", "Input label symbol table"); +DEFINE_string(osymbols, "", "Output label symbol table"); +DEFINE_string(ssymbols, "", "State label symbol table"); +DEFINE_bool(numeric, false, "Print numeric labels?"); +DEFINE_string(save_isymbols, "", "Save input symbol table to file"); +DEFINE_string(save_osymbols, "", "Save output symbol table to file"); +DEFINE_bool(show_weight_one, false, + "Print/draw arc weights and final weights equal to semiring One?"); +DEFINE_bool(allow_negative_labels, false, + "Allow negative labels (not recommended; may cause conflicts)?"); +DEFINE_string(missing_symbol, "", + "Symbol to print when lookup fails (default raises error)"); + +int fstprint_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstprint_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstproject-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstproject-main.cc new file mode 100644 index 0000000000..746cf82fac --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstproject-main.cc @@ -0,0 +1,43 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Projects a transduction onto its input or output language. + +#include + +#include +#include + +#include +#include +#include + +DECLARE_bool(project_output); + +int fstproject_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::MutableFstClass; + + string usage = + "Projects a transduction onto its input" + " or output language.\n\n Usage: "; + usage += argv[0]; + usage += " [in.fst [out.fst]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr fst(MutableFstClass::Read(in_name, true)); + if (!fst) return 1; + + s::Project(fst.get(), s::GetProjectType(FLAGS_project_output)); + + return !fst->Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstproject.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstproject.cc new file mode 100644 index 0000000000..1cfb9131f7 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstproject.cc @@ -0,0 +1,10 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +DEFINE_bool(project_output, false, "Project on output (vs. input)"); + +int fstproject_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstproject_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstprune-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstprune-main.cc new file mode 100644 index 0000000000..7d802ad07e --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstprune-main.cc @@ -0,0 +1,47 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Prunes states and arcs of an FST w.r.t. the shortest path weight. + +#include + +#include +#include + +#include +#include + +DECLARE_double(delta); +DECLARE_int64(nstate); +DECLARE_string(weight); + +int fstprune_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::MutableFstClass; + using fst::script::WeightClass; + + string usage = "Prunes states and arcs of an FST.\n\n Usage: "; + usage += argv[0]; + usage += " [in.fst [out.fst]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr fst(MutableFstClass::Read(in_name, true)); + if (!fst) return 1; + + const auto weight_threshold = + FLAGS_weight.empty() ? WeightClass::Zero(fst->WeightType()) + : WeightClass(fst->WeightType(), FLAGS_weight); + + s::Prune(fst.get(), weight_threshold, FLAGS_nstate, FLAGS_delta); + + return !fst->Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstprune.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstprune.cc new file mode 100644 index 0000000000..3902f451c9 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstprune.cc @@ -0,0 +1,14 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +DEFINE_double(delta, fst::kDelta, "Comparison/quantization delta"); +DEFINE_int64(nstate, fst::kNoStateId, "State number threshold"); +DEFINE_string(weight, "", "Weight threshold"); + +int fstprune_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstprune_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstpush-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstpush-main.cc new file mode 100644 index 0000000000..c70067ba44 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstpush-main.cc @@ -0,0 +1,55 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Pushes weights and/or output labels in an FST toward the initial or final +// states. + +#include + +#include +#include + +#include +#include +#include + +DECLARE_double(delta); +DECLARE_bool(push_weights); +DECLARE_bool(push_labels); +DECLARE_bool(remove_total_weight); +DECLARE_bool(remove_common_affix); +DECLARE_bool(to_final); + +int fstpush_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + using fst::script::VectorFstClass; + + string usage = "Pushes weights and/or olabels in an FST.\n\n Usage: "; + usage += argv[0]; + usage += " [in.fst [out.fst]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; + string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr ifst(FstClass::Read(in_name)); + if (!ifst) return 1; + + const auto flags = + s::GetPushFlags(FLAGS_push_weights, FLAGS_push_labels, + FLAGS_remove_total_weight, FLAGS_remove_common_affix); + + VectorFstClass ofst(ifst->ArcType()); + + s::Push(*ifst, &ofst, flags, s::GetReweightType(FLAGS_to_final), + FLAGS_delta); + + return !ofst.Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstpush.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstpush.cc new file mode 100644 index 0000000000..c04d38d4b0 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstpush.cc @@ -0,0 +1,18 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +DEFINE_double(delta, fst::kDelta, "Comparison/quantization delta"); +DEFINE_bool(push_weights, false, "Push weights"); +DEFINE_bool(push_labels, false, "Push output labels"); +DEFINE_bool(remove_total_weight, false, + "Remove total weight when pushing weights"); +DEFINE_bool(remove_common_affix, false, + "Remove common prefix/suffix when pushing labels"); +DEFINE_bool(to_final, false, "Push/reweight to final (vs. to initial) states"); + +int fstpush_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstpush_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstrandgen-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstrandgen-main.cc new file mode 100644 index 0000000000..75047367e4 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstrandgen-main.cc @@ -0,0 +1,62 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Generates random paths through an FST. + +#include + +#include +#include + +#include +#include +#include +#include + +DECLARE_int32(max_length); +DECLARE_int32(npath); +DECLARE_int32(seed); +DECLARE_string(select); +DECLARE_bool(weighted); +DECLARE_bool(remove_total_weight); + +int fstrandgen_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + using fst::script::VectorFstClass; + + string usage = "Generates random paths through an FST.\n\n Usage: "; + usage += argv[0]; + usage += " [in.fst [out.fst]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + VLOG(1) << argv[0] << ": Seed = " << FLAGS_seed; + + const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr ifst(FstClass::Read(in_name)); + if (!ifst) return 1; + + VectorFstClass ofst(ifst->ArcType()); + + s::RandArcSelection ras; + if (!s::GetRandArcSelection(FLAGS_select, &ras)) { + LOG(ERROR) << argv[0] << ": Unknown or unsupported select type " + << FLAGS_select; + return 1; + } + + s::RandGen(*ifst, &ofst, FLAGS_seed, + fst::RandGenOptions( + ras, FLAGS_max_length, FLAGS_npath, FLAGS_weighted, + FLAGS_remove_total_weight)); + + return !ofst.Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstrandgen.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstrandgen.cc new file mode 100644 index 0000000000..5af92317a2 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstrandgen.cc @@ -0,0 +1,22 @@ +#include + +#include +#include + +#include + +DEFINE_int32(max_length, INT32_MAX, "Maximum path length"); +DEFINE_int32(npath, 1, "Number of paths to generate"); +DEFINE_int32(seed, time(nullptr) + getpid(), "Random seed"); +DEFINE_string(select, "uniform", + "Selection type: one of: " + " \"uniform\", \"log_prob\" (when appropriate)," + " \"fast_log_prob\" (when appropriate)"); +DEFINE_bool(weighted, false, + "Output tree weighted by path count vs. unweighted paths"); +DEFINE_bool(remove_total_weight, false, + "Remove total weight when output weighted"); + +int fstrandgen_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstrandgen_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstrelabel-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstrelabel-main.cc new file mode 100644 index 0000000000..41970d742e --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstrelabel-main.cc @@ -0,0 +1,104 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Relabels input or output space of an FST. + +#include + +#include +#include +#include + +#include +#include +#include +#include + +DECLARE_string(isymbols); +DECLARE_string(osymbols); +DECLARE_string(relabel_isymbols); +DECLARE_string(relabel_osymbols); +DECLARE_string(relabel_ipairs); +DECLARE_string(relabel_opairs); +DECLARE_string(unknown_isymbol); +DECLARE_string(unknown_osymbol); +DECLARE_bool(allow_negative_labels); + +int fstrelabel_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::MutableFstClass; + using fst::SymbolTable; + using fst::SymbolTableTextOptions; + + string usage = + "Relabels the input and/or the output labels of the FST.\n\n" + " Usage: "; + usage += argv[0]; + usage += " [in.fst [out.fst]]\n"; + usage += "\n Using SymbolTables flags:\n"; + usage += " --relabel_isymbols isyms.map\n"; + usage += " --relabel_osymbols osyms.map\n"; + usage += "\n Using numeric labels flags:\n"; + usage += " --relabel_ipairs ipairs.txt\n"; + usage += " --relabel_opairs opairs.txt\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = + (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr fst(MutableFstClass::Read(in_name, true)); + if (!fst) return 1; + + // Relabel with symbol tables. + const SymbolTableTextOptions opts(FLAGS_allow_negative_labels); + + if (!FLAGS_relabel_isymbols.empty() || !FLAGS_relabel_osymbols.empty()) { + bool attach_new_isymbols = (fst->InputSymbols() != nullptr); + std::unique_ptr old_isymbols( + FLAGS_isymbols.empty() ? nullptr + : SymbolTable::ReadText(FLAGS_isymbols, opts)); + const std::unique_ptr relabel_isymbols( + FLAGS_relabel_isymbols.empty() + ? nullptr + : SymbolTable::ReadText(FLAGS_relabel_isymbols, opts)); + bool attach_new_osymbols = (fst->OutputSymbols() != nullptr); + std::unique_ptr old_osymbols( + FLAGS_osymbols.empty() ? nullptr + : SymbolTable::ReadText(FLAGS_osymbols, opts)); + const std::unique_ptr relabel_osymbols( + FLAGS_relabel_osymbols.empty() + ? nullptr + : SymbolTable::ReadText(FLAGS_relabel_osymbols, opts)); + s::Relabel(fst.get(), + old_isymbols ? old_isymbols.get() : fst->InputSymbols(), + relabel_isymbols.get(), FLAGS_unknown_isymbol, + attach_new_isymbols, + old_osymbols ? old_osymbols.get() : fst->OutputSymbols(), + relabel_osymbols.get(), FLAGS_unknown_osymbol, + attach_new_osymbols); + } else { + // Reads in relabeling pairs. + std::vector ipairs; + std::vector opairs; + if (!FLAGS_relabel_ipairs.empty()) { + if (!fst::ReadLabelPairs(FLAGS_relabel_ipairs, &ipairs, + FLAGS_allow_negative_labels)) + return 1; + } + if (!FLAGS_relabel_opairs.empty()) { + if (!fst::ReadLabelPairs(FLAGS_relabel_opairs, &opairs, + FLAGS_allow_negative_labels)) + return 1; + } + s::Relabel(fst.get(), ipairs, opairs); + } + + return !fst->Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstrelabel.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstrelabel.cc new file mode 100644 index 0000000000..29f24efdf7 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstrelabel.cc @@ -0,0 +1,21 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +DEFINE_string(isymbols, "", "Input label symbol table"); +DEFINE_string(osymbols, "", "Output label symbol table"); +DEFINE_string(relabel_isymbols, "", "Input symbol set to relabel to"); +DEFINE_string(relabel_osymbols, "", "Output symbol set to relabel to"); +DEFINE_string(relabel_ipairs, "", "Input relabel pairs (numeric)"); +DEFINE_string(relabel_opairs, "", "Output relabel pairs (numeric)"); +DEFINE_string(unknown_isymbol, "", + "Input symbol to use to relabel OOVs (default: OOVs are errors)"); +DEFINE_string(unknown_osymbol, "", + "Output symbol to use to relabel OOVs (default: OOVs are errors)"); +DEFINE_bool(allow_negative_labels, false, + "Allow negative labels (not recommended; may cause conflicts)"); + +int fstrelabel_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstrelabel_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstreplace-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstreplace-main.cc new file mode 100644 index 0000000000..0c4eeb0e0a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstreplace-main.cc @@ -0,0 +1,91 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Performs the dynamic replacement of arcs in one FST with another FST, +// allowing for the definition of FSTs analogous to RTNs. + +#include + +#include +#include + +#include +#include +#include + +DECLARE_string(call_arc_labeling); +DECLARE_string(return_arc_labeling); +DECLARE_int64(return_label); +DECLARE_bool(epsilon_on_replace); + +void Cleanup(std::vector *pairs) { + for (const auto &pair : *pairs) { + delete pair.second; + } + pairs->clear(); +} + +int fstreplace_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + using fst::script::VectorFstClass; + using fst::ReplaceLabelType; + + string usage = "Recursively replaces FST arcs with other FST(s).\n\n" + " Usage: "; + usage += argv[0]; + usage += " root.fst rootlabel [rule1.fst label1 ...] [out.fst]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc < 4) { + ShowUsage(); + return 1; + } + + const string in_name = argv[1]; + const string out_name = argc % 2 == 0 ? argv[argc - 1] : ""; + + auto *ifst = FstClass::Read(in_name); + if (!ifst) return 1; + + std::vector pairs; + // Note that if the root label is beyond the range of the underlying FST's + // labels, truncation will occur. + const auto root = atoll(argv[2]); + pairs.emplace_back(root, ifst); + + for (auto i = 3; i < argc - 1; i += 2) { + ifst = FstClass::Read(argv[i]); + if (!ifst) { + Cleanup(&pairs); + return 1; + } + // Note that if the root label is beyond the range of the underlying FST's + // labels, truncation will occur. + const auto label = atoll(argv[i + 1]); + pairs.emplace_back(label, ifst); + } + + ReplaceLabelType call_label_type; + if (!s::GetReplaceLabelType(FLAGS_call_arc_labeling, FLAGS_epsilon_on_replace, + &call_label_type)) { + LOG(ERROR) << argv[0] << ": Unknown or unsupported call arc replace " + << "label type: " << FLAGS_call_arc_labeling; + } + ReplaceLabelType return_label_type; + if (!s::GetReplaceLabelType(FLAGS_return_arc_labeling, + FLAGS_epsilon_on_replace, &return_label_type)) { + LOG(ERROR) << argv[0] << ": Unknown or unsupported return arc replace " + << "label type: " << FLAGS_return_arc_labeling; + } + + s::ReplaceOptions opts(root, call_label_type, return_label_type, + FLAGS_return_label); + + VectorFstClass ofst(ifst->ArcType()); + s::Replace(pairs, &ofst, opts); + Cleanup(&pairs); + + return !ofst.Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstreplace.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstreplace.cc new file mode 100644 index 0000000000..0cab330a0b --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstreplace.cc @@ -0,0 +1,17 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +DEFINE_string(call_arc_labeling, "input", + "Which labels to make non-epsilon on the call arc. " + "One of: \"input\" (default), \"output\", \"both\", \"neither\""); +DEFINE_string(return_arc_labeling, "neither", + "Which labels to make non-epsilon on the return arc. " + "One of: \"input\", \"output\", \"both\", \"neither\" (default)"); +DEFINE_int64(return_label, 0, "Label to put on return arc"); +DEFINE_bool(epsilon_on_replace, false, "Call/return arcs are epsilon arcs?"); + +int fstreplace_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstreplace_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstreverse-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstreverse-main.cc new file mode 100644 index 0000000000..86f18c2227 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstreverse-main.cc @@ -0,0 +1,45 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Reverses the paths in an FST. + +#include + +#include +#include + +#include +#include +#include + +DECLARE_bool(require_superinitial); + +int fstreverse_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + using fst::script::VectorFstClass; + + string usage = "Reverses the paths in an FST.\n\n Usage: "; + usage += argv[0]; + usage += " [in.fst [out.fst]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = + (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr ifst(FstClass::Read(in_name)); + if (!ifst) return 1; + + VectorFstClass ofst(ifst->ArcType()); + + s::Reverse(*ifst, &ofst, FLAGS_require_superinitial); + + return !ofst.Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstreverse.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstreverse.cc new file mode 100644 index 0000000000..cdc10d6c13 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstreverse.cc @@ -0,0 +1,10 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +DEFINE_bool(require_superinitial, true, "Always create a superinitial state"); + +int fstreverse_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstreverse_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstreweight-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstreweight-main.cc new file mode 100644 index 0000000000..8ca8d84ebd --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstreweight-main.cc @@ -0,0 +1,50 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Reweights an FST. + +#include + +#include +#include +#include + +#include +#include +#include +#include + +DECLARE_bool(to_final); + +int fstreweight_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::MutableFstClass; + using fst::script::WeightClass; + + string usage = "Reweights an FST.\n\n Usage: "; + usage += argv[0]; + usage += " in.fst potential.txt [out.fst]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc < 3 || argc > 4) { + ShowUsage(); + return 1; + } + + const string in_name = argv[1]; + const string potentials_name = argv[2]; + const string out_name = argc > 3 ? argv[3] : ""; + + std::unique_ptr fst(MutableFstClass::Read(in_name, true)); + if (!fst) return 1; + + std::vector potential; + if (!s::ReadPotentials(fst->WeightType(), potentials_name, &potential)) { + return 1; + } + + s::Reweight(fst.get(), potential, s::GetReweightType(FLAGS_to_final)); + + return !fst->Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstreweight.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstreweight.cc new file mode 100644 index 0000000000..6e2c83c612 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstreweight.cc @@ -0,0 +1,10 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +DEFINE_bool(to_final, false, "Push/reweight to final (vs. to initial) states"); + +int fstreweight_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstreweight_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstrmepsilon-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstrmepsilon-main.cc new file mode 100644 index 0000000000..c457d17d73 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstrmepsilon-main.cc @@ -0,0 +1,61 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Removes epsilons from an FST. + +#include + +#include +#include + +#include +#include +#include +#include + +DECLARE_bool(connect); +DECLARE_double(delta); +DECLARE_int64(nstate); +DECLARE_string(queue_type); +DECLARE_string(weight); + +int fstrmepsilon_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::MutableFstClass; + using fst::script::WeightClass; + + string usage = "Removes epsilons from an FST.\n\n Usage: "; + usage += argv[0]; + usage += " [in.fst [out.fst]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr fst(MutableFstClass::Read(in_name, true)); + if (!fst) return 1; + + const auto weight_threshold = + FLAGS_weight.empty() ? WeightClass::Zero(fst->WeightType()) + : WeightClass(fst->WeightType(), FLAGS_weight); + + fst::QueueType queue_type; + if (!s::GetQueueType(FLAGS_queue_type, &queue_type)) { + LOG(ERROR) << argv[0] + << ": Unknown or unsupported queue type: " << FLAGS_queue_type; + return 1; + } + + const s::RmEpsilonOptions opts(queue_type, FLAGS_connect, weight_threshold, + FLAGS_nstate, FLAGS_delta); + + s::RmEpsilon(fst.get(), opts); + + return !fst->Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstrmepsilon.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstrmepsilon.cc new file mode 100644 index 0000000000..c249c529f5 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstrmepsilon.cc @@ -0,0 +1,19 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include +#include + +DEFINE_bool(connect, true, "Trim output"); +DEFINE_double(delta, fst::kShortestDelta, "Comparison/quantization delta"); +DEFINE_int64(nstate, fst::kNoStateId, "State number threshold"); +DEFINE_string(queue_type, "auto", + "Queue type: one of: \"auto\", " + "\"fifo\", \"lifo\", \"shortest\", \"state\", \"top\""); +DEFINE_string(weight, "", "Weight threshold"); + +int fstrmepsilon_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstrmepsilon_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstshortestdistance-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstshortestdistance-main.cc new file mode 100644 index 0000000000..1bf2eb3814 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstshortestdistance-main.cc @@ -0,0 +1,70 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Find shortest distances in an FST. + +#include + +#include +#include +#include + +#include +#include +#include +#include +#include + +DECLARE_bool(reverse); +DECLARE_double(delta); +DECLARE_int64(nstate); +DECLARE_string(queue_type); + +int fstshortestdistance_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + using fst::script::WeightClass; + using fst::QueueType; + using fst::AUTO_QUEUE; + + string usage = "Finds shortest distance(s) in an FST.\n\n Usage: "; + usage += argv[0]; + usage += " [in.fst [distance.txt]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + string in_name = (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : ""; + string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr ifst(FstClass::Read(in_name)); + if (!ifst) return 1; + + std::vector distance; + + QueueType queue_type; + if (!s::GetQueueType(FLAGS_queue_type, &queue_type)) { + LOG(ERROR) << argv[0] + << ": Unknown or unsupported queue type: " << FLAGS_queue_type; + return 1; + } + + if (FLAGS_reverse && queue_type != AUTO_QUEUE) { + LOG(ERROR) << argv[0] << ": Can't use non-default queue with reverse"; + return 1; + } + + if (FLAGS_reverse) { + s::ShortestDistance(*ifst, &distance, FLAGS_reverse, FLAGS_delta); + } else { + const s::ShortestDistanceOptions opts(queue_type, s::ANY_ARC_FILTER, + FLAGS_nstate, FLAGS_delta); + s::ShortestDistance(*ifst, &distance, opts); + } + + return !s::WritePotentials(out_name, distance); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstshortestdistance.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstshortestdistance.cc new file mode 100644 index 0000000000..63e6537acf --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstshortestdistance.cc @@ -0,0 +1,18 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include +#include + +DEFINE_bool(reverse, false, "Perform in the reverse direction"); +DEFINE_double(delta, fst::kShortestDelta, "Comparison/quantization delta"); +DEFINE_int64(nstate, fst::kNoStateId, "State number threshold"); +DEFINE_string(queue_type, "auto", + "Queue type: one of: \"auto\", " + "\"fifo\", \"lifo\", \"shortest\", \"state\", \"top\""); + +int fstshortestdistance_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstshortestdistance_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstshortestpath-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstshortestpath-main.cc new file mode 100644 index 0000000000..9becf8f626 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstshortestpath-main.cc @@ -0,0 +1,67 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Find shortest path(s) in an FST. + +#include + +#include +#include +#include + +#include +#include +#include +#include + +DECLARE_double(delta); +DECLARE_int32(nshortest); +DECLARE_int64(nstate); +DECLARE_string(queue_type); +DECLARE_bool(unique); +DECLARE_string(weight); + +int fstshortestpath_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + using fst::script::WeightClass; + using fst::script::VectorFstClass; + + string usage = "Finds shortest path(s) in an FST.\n\n Usage: "; + usage += argv[0]; + usage += " [in.fst [out.fst]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = + (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr ifst(FstClass::Read(in_name)); + if (!ifst) return 1; + + const auto weight_threshold = + FLAGS_weight.empty() ? WeightClass::Zero(ifst->WeightType()) + : WeightClass(ifst->WeightType(), FLAGS_weight); + + VectorFstClass ofst(ifst->ArcType()); + + fst::QueueType queue_type; + if (!s::GetQueueType(FLAGS_queue_type, &queue_type)) { + LOG(ERROR) << "Unknown or unsupported queue type: " << FLAGS_queue_type; + return 1; + } + + const s::ShortestPathOptions opts(queue_type, FLAGS_nshortest, + FLAGS_unique, FLAGS_delta, + weight_threshold, FLAGS_nstate); + + s::ShortestPath(*ifst, &ofst, opts); + + return !ofst.Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstshortestpath.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstshortestpath.cc new file mode 100644 index 0000000000..722897a1c4 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstshortestpath.cc @@ -0,0 +1,20 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include +#include + +DEFINE_double(delta, fst::kShortestDelta, "Comparison/quantization delta"); +DEFINE_int32(nshortest, 1, "Return N-shortest paths"); +DEFINE_int64(nstate, fst::kNoStateId, "State number threshold"); +DEFINE_string(queue_type, "auto", + "Queue type: one of \"auto\", " + "\"fifo\", \"lifo\", \"shortest\', \"state\", \"top\""); +DEFINE_bool(unique, false, "Return unique strings"); +DEFINE_string(weight, "", "Weight threshold"); + +int fstshortestpath_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstshortestpath_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstsymbols-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstsymbols-main.cc new file mode 100644 index 0000000000..bf6f974ad3 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstsymbols-main.cc @@ -0,0 +1,111 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Performs operations (set, clear, relabel) on the symbols table attached to an +// input FST. + +#include + +#include +#include +#include + +#include +#include +#include +#include + +DECLARE_string(isymbols); +DECLARE_string(osymbols); +DECLARE_bool(clear_isymbols); +DECLARE_bool(clear_osymbols); +DECLARE_string(relabel_ipairs); +DECLARE_string(relabel_opairs); +DECLARE_string(save_isymbols); +DECLARE_string(save_osymbols); +DECLARE_bool(allow_negative_labels); +DECLARE_bool(verify); + +int fstsymbols_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::MutableFstClass; + using fst::ReadLabelPairs; + using fst::SymbolTable; + using fst::SymbolTableTextOptions; + + string usage = + "Performs operations (set, clear, relabel) on the symbol" + " tables attached to an FST.\n\n Usage: "; + usage += argv[0]; + usage += " [in.fst [out.fst]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = argc > 1 && strcmp(argv[1], "-") != 0 ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr fst(MutableFstClass::Read(in_name, true)); + if (!fst) return 1; + + if (!FLAGS_save_isymbols.empty()) { + const auto *isyms = fst->InputSymbols(); + if (isyms) { + isyms->WriteText(FLAGS_save_isymbols); + } else { + LOG(ERROR) << argv[0] + << ": Saving isymbols but there are no input symbols."; + } + } + + if (!FLAGS_save_osymbols.empty()) { + const auto *osyms = fst->OutputSymbols(); + if (osyms) { + osyms->WriteText(FLAGS_save_osymbols); + } else { + LOG(ERROR) << argv[0] + << ": Saving osymbols but there are no output symbols."; + } + } + + const SymbolTableTextOptions opts(FLAGS_allow_negative_labels); + + std::unique_ptr isyms; + if (!FLAGS_isymbols.empty()) { + isyms.reset(SymbolTable::ReadText(FLAGS_isymbols, opts)); + fst->SetInputSymbols(isyms.get()); + } else if (FLAGS_clear_isymbols) { + fst->SetInputSymbols(nullptr); + } + std::unique_ptr osyms; + if (!FLAGS_osymbols.empty()) { + osyms.reset(SymbolTable::ReadText(FLAGS_osymbols, opts)); + fst->SetOutputSymbols(osyms.get()); + } else if (FLAGS_clear_osymbols) { + fst->SetOutputSymbols(nullptr); + } + + using Label = int64; + if (!FLAGS_relabel_ipairs.empty()) { + std::vector> ipairs; + ReadLabelPairs(FLAGS_relabel_ipairs, &ipairs, FLAGS_allow_negative_labels); + std::unique_ptr isyms_relabel( + RelabelSymbolTable(fst->InputSymbols(), ipairs)); + fst->SetInputSymbols(isyms_relabel.get()); + } + if (!FLAGS_relabel_opairs.empty()) { + std::vector> opairs; + ReadLabelPairs(FLAGS_relabel_opairs, &opairs, FLAGS_allow_negative_labels); + std::unique_ptr osyms_relabel( + RelabelSymbolTable(fst->OutputSymbols(), opairs)); + fst->SetOutputSymbols(osyms_relabel.get()); + } + + if (FLAGS_verify && !s::Verify(*fst)) return 1; + + return !fst->Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstsymbols.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstsymbols.cc new file mode 100644 index 0000000000..62085fee2a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstsymbols.cc @@ -0,0 +1,20 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +DEFINE_string(isymbols, "", "Input label symbol table"); +DEFINE_string(osymbols, "", "Output label symbol table"); +DEFINE_bool(clear_isymbols, false, "Clear input symbol table"); +DEFINE_bool(clear_osymbols, false, "Clear output symbol table"); +DEFINE_string(relabel_ipairs, "", "Input relabel pairs (numeric)"); +DEFINE_string(relabel_opairs, "", "Output relabel pairs (numeric)"); +DEFINE_string(save_isymbols, "", "Save fst file's input symbol table to file"); +DEFINE_string(save_osymbols, "", "Save fst file's output symbol table to file"); +DEFINE_bool(allow_negative_labels, false, + "Allow negative labels (not recommended; may cause conflicts)"); +DEFINE_bool(verify, false, "Verify fst properities before saving"); + +int fstsymbols_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstsymbols_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstsynchronize-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstsynchronize-main.cc new file mode 100644 index 0000000000..fe23093c27 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstsynchronize-main.cc @@ -0,0 +1,41 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Synchronizes an FST. + +#include + +#include +#include + +#include +#include + +int fstsynchronize_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + using fst::script::VectorFstClass; + + string usage = "Synchronizes an FST.\n\n Usage: "; + usage += argv[0]; + usage += " [in.fst [out.fst]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr ifst(FstClass::Read(in_name)); + if (!ifst) return 1; + + VectorFstClass ofst(ifst->ArcType()); + + s::Synchronize(*ifst, &ofst); + + return !ofst.Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstsynchronize.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstsynchronize.cc new file mode 100644 index 0000000000..a0525fcfb0 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstsynchronize.cc @@ -0,0 +1,6 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +int fstsynchronize_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstsynchronize_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fsttopsort-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fsttopsort-main.cc new file mode 100644 index 0000000000..879d5dc31a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fsttopsort-main.cc @@ -0,0 +1,41 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Topologically sorts an FST. + +#include + +#include +#include + +#include +#include +#include + +int fsttopsort_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::MutableFstClass; + + string usage = "Topologically sorts an FST.\n\n Usage: "; + usage += argv[0]; + usage += " [in.fst [out.fst]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = argc > 1 && strcmp(argv[1], "-") != 0 ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr fst(MutableFstClass::Read(in_name, true)); + if (!fst) return 1; + + bool acyclic = TopSort(fst.get()); + + if (!acyclic) LOG(WARNING) << argv[0] << ": Input FST is cyclic"; + + return !fst->Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fsttopsort.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fsttopsort.cc new file mode 100644 index 0000000000..68726c7020 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fsttopsort.cc @@ -0,0 +1,6 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +int fsttopsort_main(int argc, char **argv); + +int main(int argc, char **argv) { return fsttopsort_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstunion-main.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstunion-main.cc new file mode 100644 index 0000000000..995d03ebf9 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstunion-main.cc @@ -0,0 +1,49 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Creates the union of two FSTs. + +#include + +#include +#include + +#include +#include +#include + +int fstunion_main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + using fst::script::MutableFstClass; + + string usage = "Creates the union of two FSTs.\n\n Usage: "; + usage += argv[0]; + usage += " in1.fst in2.fst [out.fst]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc < 3 || argc > 4) { + ShowUsage(); + return 1; + } + + const string in1_name = strcmp(argv[1], "-") != 0 ? argv[1] : ""; + const string in2_name = strcmp(argv[2], "-") != 0 ? argv[2] : ""; + const string out_name = argc > 3 ? argv[3] : ""; + + if (in1_name == "" && in2_name == "") { + LOG(ERROR) << argv[0] << ": Can't take both inputs from standard input"; + return 1; + } + + std::unique_ptr fst1(MutableFstClass::Read(in1_name, true)); + if (!fst1) return 1; + + std::unique_ptr fst2(FstClass::Read(in2_name)); + if (!fst2) return 1; + + s::Union(fst1.get(), *fst2); + + return !fst1->Write(out_name); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstunion.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstunion.cc new file mode 100644 index 0000000000..2aba499bba --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/bin/fstunion.cc @@ -0,0 +1,6 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +int fstunion_main(int argc, char **argv); + +int main(int argc, char **argv) { return fstunion_main(argc, argv); } diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/Makefile.am b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/Makefile.am new file mode 100644 index 0000000000..f42e078b32 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/Makefile.am @@ -0,0 +1,55 @@ +if HAVE_COMPACT +compactdir = compact +endif + +if HAVE_COMPRESS +compressdir = compress +endif + +if HAVE_CONST +constdir = const +endif + +if HAVE_FAR +fardir = far +endif + +if HAVE_GRM +fardir = far +pdtdir = pdt +mpdtdir = mpdt +endif + +if HAVE_LINEAR +lineardir = linear +endif + +if HAVE_LOOKAHEAD +lookaheaddir = lookahead +endif + +if HAVE_MPDT +pdtdir = pdt +mpdtdir = mpdt +endif + +if HAVE_NGRAM +ngramdir = ngram +endif + +if HAVE_PYTHON +fardir = far +pywrapfstdir = python +endif + +if HAVE_PDT +pdtdir = pdt +endif + +if HAVE_SPECIAL +specialdir = special +endif + +SUBDIRS = $(compactdir) $(compressdir) $(constdir) $(fardir) $(lineardir) \ + $(lookaheaddir) $(pdtdir) $(mpdtdir) $(ngramdir) $(pywrapfstdir) \ + $(specialdir) diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/Makefile.in b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/Makefile.in new file mode 100644 index 0000000000..92403f138a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/Makefile.in @@ -0,0 +1,644 @@ +# Makefile.in generated by automake 1.14.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2013 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ +VPATH = @srcdir@ +am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +subdir = src/extensions +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \ + $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ + $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ + $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h \ + $(top_builddir)/src/include/fst/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +SOURCES = +DIST_SOURCES = +RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \ + ctags-recursive dvi-recursive html-recursive info-recursive \ + install-data-recursive install-dvi-recursive \ + install-exec-recursive install-html-recursive \ + install-info-recursive install-pdf-recursive \ + install-ps-recursive install-recursive installcheck-recursive \ + installdirs-recursive pdf-recursive ps-recursive \ + tags-recursive uninstall-recursive +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \ + distclean-recursive maintainer-clean-recursive +am__recursive_targets = \ + $(RECURSIVE_TARGETS) \ + $(RECURSIVE_CLEAN_TARGETS) \ + $(am__extra_recursive_targets) +AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \ + distdir +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +DIST_SUBDIRS = compact compress const far linear lookahead pdt mpdt \ + ngram python special +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +am__relativize = \ + dir0=`pwd`; \ + sed_first='s,^\([^/]*\)/.*$$,\1,'; \ + sed_rest='s,^[^/]*/*,,'; \ + sed_last='s,^.*/\([^/]*\)$$,\1,'; \ + sed_butlast='s,/*[^/]*$$,,'; \ + while test -n "$$dir1"; do \ + first=`echo "$$dir1" | sed -e "$$sed_first"`; \ + if test "$$first" != "."; then \ + if test "$$first" = ".."; then \ + dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \ + dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \ + else \ + first2=`echo "$$dir2" | sed -e "$$sed_first"`; \ + if test "$$first2" = "$$first"; then \ + dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \ + else \ + dir2="../$$dir2"; \ + fi; \ + dir0="$$dir0"/"$$first"; \ + fi; \ + fi; \ + dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \ + done; \ + reldir="$$dir2" +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DL_LIBS = @DL_LIBS@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PYTHON = @PYTHON@ +PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@ +PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ +PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@ +PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@ +PYTHON_LDFLAGS = @PYTHON_LDFLAGS@ +PYTHON_PLATFORM = @PYTHON_PLATFORM@ +PYTHON_PREFIX = @PYTHON_PREFIX@ +PYTHON_SITE_PKG = @PYTHON_SITE_PKG@ +PYTHON_VERSION = @PYTHON_VERSION@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +libfstdir = @libfstdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgpyexecdir = @pkgpyexecdir@ +pkgpythondir = @pkgpythondir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +pyexecdir = @pyexecdir@ +pythondir = @pythondir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +@HAVE_COMPACT_TRUE@compactdir = compact +@HAVE_COMPRESS_TRUE@compressdir = compress +@HAVE_CONST_TRUE@constdir = const +@HAVE_FAR_TRUE@fardir = far +@HAVE_GRM_TRUE@fardir = far +@HAVE_PYTHON_TRUE@fardir = far +@HAVE_GRM_TRUE@pdtdir = pdt +@HAVE_MPDT_TRUE@pdtdir = pdt +@HAVE_PDT_TRUE@pdtdir = pdt +@HAVE_GRM_TRUE@mpdtdir = mpdt +@HAVE_MPDT_TRUE@mpdtdir = mpdt +@HAVE_LINEAR_TRUE@lineardir = linear +@HAVE_LOOKAHEAD_TRUE@lookaheaddir = lookahead +@HAVE_NGRAM_TRUE@ngramdir = ngram +@HAVE_PYTHON_TRUE@pywrapfstdir = python +@HAVE_SPECIAL_TRUE@specialdir = special +SUBDIRS = $(compactdir) $(compressdir) $(constdir) $(fardir) $(lineardir) \ + $(lookaheaddir) $(pdtdir) $(mpdtdir) $(ngramdir) $(pywrapfstdir) \ + $(specialdir) + +all: all-recursive + +.SUFFIXES: +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign src/extensions/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +# This directory's subdirectories are mostly independent; you can cd +# into them and run 'make' without going through this Makefile. +# To change the values of 'make' variables: instead of editing Makefiles, +# (1) if the variable is set in 'config.status', edit 'config.status' +# (which will cause the Makefiles to be regenerated when you run 'make'); +# (2) otherwise, pass the desired values on the 'make' command line. +$(am__recursive_targets): + @fail=; \ + if $(am__make_keepgoing); then \ + failcom='fail=yes'; \ + else \ + failcom='exit 1'; \ + fi; \ + dot_seen=no; \ + target=`echo $@ | sed s/-recursive//`; \ + case "$@" in \ + distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \ + *) list='$(SUBDIRS)' ;; \ + esac; \ + for subdir in $$list; do \ + echo "Making $$target in $$subdir"; \ + if test "$$subdir" = "."; then \ + dot_seen=yes; \ + local_target="$$target-am"; \ + else \ + local_target="$$target"; \ + fi; \ + ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ + || eval $$failcom; \ + done; \ + if test "$$dot_seen" = "no"; then \ + $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \ + fi; test -z "$$fail" + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-recursive +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \ + include_option=--etags-include; \ + empty_fix=.; \ + else \ + include_option=--include; \ + empty_fix=; \ + fi; \ + list='$(SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + test ! -f $$subdir/TAGS || \ + set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \ + fi; \ + done; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-recursive + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscopelist: cscopelist-recursive + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done + @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + $(am__make_dryrun) \ + || test -d "$(distdir)/$$subdir" \ + || $(MKDIR_P) "$(distdir)/$$subdir" \ + || exit 1; \ + dir1=$$subdir; dir2="$(distdir)/$$subdir"; \ + $(am__relativize); \ + new_distdir=$$reldir; \ + dir1=$$subdir; dir2="$(top_distdir)"; \ + $(am__relativize); \ + new_top_distdir=$$reldir; \ + echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \ + echo " am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \ + ($(am__cd) $$subdir && \ + $(MAKE) $(AM_MAKEFLAGS) \ + top_distdir="$$new_top_distdir" \ + distdir="$$new_distdir" \ + am__remove_distdir=: \ + am__skip_length_check=: \ + am__skip_mode_fix=: \ + distdir) \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-recursive +all-am: Makefile +installdirs: installdirs-recursive +installdirs-am: +install: install-recursive +install-exec: install-exec-recursive +install-data: install-data-recursive +uninstall: uninstall-recursive + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-recursive +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-recursive + +clean-am: clean-generic clean-libtool mostlyclean-am + +distclean: distclean-recursive + -rm -f Makefile +distclean-am: clean-am distclean-generic distclean-tags + +dvi: dvi-recursive + +dvi-am: + +html: html-recursive + +html-am: + +info: info-recursive + +info-am: + +install-data-am: + +install-dvi: install-dvi-recursive + +install-dvi-am: + +install-exec-am: + +install-html: install-html-recursive + +install-html-am: + +install-info: install-info-recursive + +install-info-am: + +install-man: + +install-pdf: install-pdf-recursive + +install-pdf-am: + +install-ps: install-ps-recursive + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-recursive + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-recursive + +mostlyclean-am: mostlyclean-generic mostlyclean-libtool + +pdf: pdf-recursive + +pdf-am: + +ps: ps-recursive + +ps-am: + +uninstall-am: + +.MAKE: $(am__recursive_targets) install-am install-strip + +.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am check \ + check-am clean clean-generic clean-libtool cscopelist-am ctags \ + ctags-am distclean distclean-generic distclean-libtool \ + distclean-tags distdir dvi dvi-am html html-am info info-am \ + install install-am install-data install-data-am install-dvi \ + install-dvi-am install-exec install-exec-am install-html \ + install-html-am install-info install-info-am install-man \ + install-pdf install-pdf-am install-ps install-ps-am \ + install-strip installcheck installcheck-am installdirs \ + installdirs-am maintainer-clean maintainer-clean-generic \ + mostlyclean mostlyclean-generic mostlyclean-libtool pdf pdf-am \ + ps ps-am tags tags-am uninstall uninstall-am + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/Makefile.am b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/Makefile.am new file mode 100644 index 0000000000..158ab16308 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/Makefile.am @@ -0,0 +1,55 @@ +AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) + +libfstdir = @libfstdir@ +libfst_LTLIBRARIES = compact8_acceptor-fst.la compact8_string-fst.la compact8_unweighted-fst.la compact8_unweighted_acceptor-fst.la compact8_weighted_string-fst.la compact16_acceptor-fst.la compact16_string-fst.la compact16_unweighted-fst.la compact16_unweighted_acceptor-fst.la compact16_weighted_string-fst.la compact64_acceptor-fst.la compact64_string-fst.la compact64_unweighted-fst.la compact64_unweighted_acceptor-fst.la compact64_weighted_string-fst.la + +lib_LTLIBRARIES = libfstcompact.la + +libfstcompact_la_SOURCES = compact8_acceptor-fst.cc compact8_string-fst.cc compact8_unweighted-fst.cc compact8_unweighted_acceptor-fst.cc compact8_weighted_string-fst.cc compact16_acceptor-fst.cc compact16_string-fst.cc compact16_unweighted-fst.cc compact16_unweighted_acceptor-fst.cc compact16_weighted_string-fst.cc compact64_acceptor-fst.cc compact64_string-fst.cc compact64_unweighted-fst.cc compact64_unweighted_acceptor-fst.cc compact64_weighted_string-fst.cc +libfstcompact_la_LDFLAGS = -version-info 10:0:0 +libfstcompact_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS) + +compact8_acceptor_fst_la_SOURCES = compact8_acceptor-fst.cc +compact8_acceptor_fst_la_LDFLAGS = -module + +compact8_string_fst_la_SOURCES = compact8_string-fst.cc +compact8_string_fst_la_LDFLAGS = -module + +compact8_unweighted_fst_la_SOURCES = compact8_unweighted-fst.cc +compact8_unweighted_fst_la_LDFLAGS = -module + +compact8_unweighted_acceptor_fst_la_SOURCES = compact8_unweighted_acceptor-fst.cc +compact8_unweighted_acceptor_fst_la_LDFLAGS = -module + +compact8_weighted_string_fst_la_SOURCES = compact8_weighted_string-fst.cc +compact8_weighted_string_fst_la_LDFLAGS = -module + +compact16_acceptor_fst_la_SOURCES = compact16_acceptor-fst.cc +compact16_acceptor_fst_la_LDFLAGS = -module + +compact16_string_fst_la_SOURCES = compact16_string-fst.cc +compact16_string_fst_la_LDFLAGS = -module + +compact16_unweighted_fst_la_SOURCES = compact16_unweighted-fst.cc +compact16_unweighted_fst_la_LDFLAGS = -module + +compact16_unweighted_acceptor_fst_la_SOURCES = compact16_unweighted_acceptor-fst.cc +compact16_unweighted_acceptor_fst_la_LDFLAGS = -module + +compact16_weighted_string_fst_la_SOURCES = compact16_weighted_string-fst.cc +compact16_weighted_string_fst_la_LDFLAGS = -module + +compact64_acceptor_fst_la_SOURCES = compact64_acceptor-fst.cc +compact64_acceptor_fst_la_LDFLAGS = -module + +compact64_string_fst_la_SOURCES = compact64_string-fst.cc +compact64_string_fst_la_LDFLAGS = -module + +compact64_unweighted_fst_la_SOURCES = compact64_unweighted-fst.cc +compact64_unweighted_fst_la_LDFLAGS = -module + +compact64_unweighted_acceptor_fst_la_SOURCES = compact64_unweighted_acceptor-fst.cc +compact64_unweighted_acceptor_fst_la_LDFLAGS = -module + +compact64_weighted_string_fst_la_SOURCES = compact64_weighted_string-fst.cc +compact64_weighted_string_fst_la_LDFLAGS = -module diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/Makefile.in b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/Makefile.in new file mode 100644 index 0000000000..d1fd4fb6a8 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/Makefile.in @@ -0,0 +1,953 @@ +# Makefile.in generated by automake 1.14.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2013 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +VPATH = @srcdir@ +am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +subdir = src/extensions/compact +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ + $(top_srcdir)/depcomp +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \ + $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ + $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ + $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h \ + $(top_builddir)/src/include/fst/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__uninstall_files_from_dir = { \ + test -z "$$files" \ + || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && rm -f $$files; }; \ + } +am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)" +LTLIBRARIES = $(lib_LTLIBRARIES) $(libfst_LTLIBRARIES) +compact16_acceptor_fst_la_LIBADD = +am_compact16_acceptor_fst_la_OBJECTS = compact16_acceptor-fst.lo +compact16_acceptor_fst_la_OBJECTS = \ + $(am_compact16_acceptor_fst_la_OBJECTS) +AM_V_lt = $(am__v_lt_@AM_V@) +am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) +am__v_lt_0 = --silent +am__v_lt_1 = +compact16_acceptor_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) \ + $(compact16_acceptor_fst_la_LDFLAGS) $(LDFLAGS) -o $@ +compact16_string_fst_la_LIBADD = +am_compact16_string_fst_la_OBJECTS = compact16_string-fst.lo +compact16_string_fst_la_OBJECTS = \ + $(am_compact16_string_fst_la_OBJECTS) +compact16_string_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) $(compact16_string_fst_la_LDFLAGS) \ + $(LDFLAGS) -o $@ +compact16_unweighted_fst_la_LIBADD = +am_compact16_unweighted_fst_la_OBJECTS = compact16_unweighted-fst.lo +compact16_unweighted_fst_la_OBJECTS = \ + $(am_compact16_unweighted_fst_la_OBJECTS) +compact16_unweighted_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) \ + $(compact16_unweighted_fst_la_LDFLAGS) $(LDFLAGS) -o $@ +compact16_unweighted_acceptor_fst_la_LIBADD = +am_compact16_unweighted_acceptor_fst_la_OBJECTS = \ + compact16_unweighted_acceptor-fst.lo +compact16_unweighted_acceptor_fst_la_OBJECTS = \ + $(am_compact16_unweighted_acceptor_fst_la_OBJECTS) +compact16_unweighted_acceptor_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) \ + --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link \ + $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) \ + $(compact16_unweighted_acceptor_fst_la_LDFLAGS) $(LDFLAGS) -o \ + $@ +compact16_weighted_string_fst_la_LIBADD = +am_compact16_weighted_string_fst_la_OBJECTS = \ + compact16_weighted_string-fst.lo +compact16_weighted_string_fst_la_OBJECTS = \ + $(am_compact16_weighted_string_fst_la_OBJECTS) +compact16_weighted_string_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) \ + --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link \ + $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) \ + $(compact16_weighted_string_fst_la_LDFLAGS) $(LDFLAGS) -o $@ +compact64_acceptor_fst_la_LIBADD = +am_compact64_acceptor_fst_la_OBJECTS = compact64_acceptor-fst.lo +compact64_acceptor_fst_la_OBJECTS = \ + $(am_compact64_acceptor_fst_la_OBJECTS) +compact64_acceptor_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) \ + $(compact64_acceptor_fst_la_LDFLAGS) $(LDFLAGS) -o $@ +compact64_string_fst_la_LIBADD = +am_compact64_string_fst_la_OBJECTS = compact64_string-fst.lo +compact64_string_fst_la_OBJECTS = \ + $(am_compact64_string_fst_la_OBJECTS) +compact64_string_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) $(compact64_string_fst_la_LDFLAGS) \ + $(LDFLAGS) -o $@ +compact64_unweighted_fst_la_LIBADD = +am_compact64_unweighted_fst_la_OBJECTS = compact64_unweighted-fst.lo +compact64_unweighted_fst_la_OBJECTS = \ + $(am_compact64_unweighted_fst_la_OBJECTS) +compact64_unweighted_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) \ + $(compact64_unweighted_fst_la_LDFLAGS) $(LDFLAGS) -o $@ +compact64_unweighted_acceptor_fst_la_LIBADD = +am_compact64_unweighted_acceptor_fst_la_OBJECTS = \ + compact64_unweighted_acceptor-fst.lo +compact64_unweighted_acceptor_fst_la_OBJECTS = \ + $(am_compact64_unweighted_acceptor_fst_la_OBJECTS) +compact64_unweighted_acceptor_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) \ + --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link \ + $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) \ + $(compact64_unweighted_acceptor_fst_la_LDFLAGS) $(LDFLAGS) -o \ + $@ +compact64_weighted_string_fst_la_LIBADD = +am_compact64_weighted_string_fst_la_OBJECTS = \ + compact64_weighted_string-fst.lo +compact64_weighted_string_fst_la_OBJECTS = \ + $(am_compact64_weighted_string_fst_la_OBJECTS) +compact64_weighted_string_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) \ + --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link \ + $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) \ + $(compact64_weighted_string_fst_la_LDFLAGS) $(LDFLAGS) -o $@ +compact8_acceptor_fst_la_LIBADD = +am_compact8_acceptor_fst_la_OBJECTS = compact8_acceptor-fst.lo +compact8_acceptor_fst_la_OBJECTS = \ + $(am_compact8_acceptor_fst_la_OBJECTS) +compact8_acceptor_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) $(compact8_acceptor_fst_la_LDFLAGS) \ + $(LDFLAGS) -o $@ +compact8_string_fst_la_LIBADD = +am_compact8_string_fst_la_OBJECTS = compact8_string-fst.lo +compact8_string_fst_la_OBJECTS = $(am_compact8_string_fst_la_OBJECTS) +compact8_string_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) $(compact8_string_fst_la_LDFLAGS) \ + $(LDFLAGS) -o $@ +compact8_unweighted_fst_la_LIBADD = +am_compact8_unweighted_fst_la_OBJECTS = compact8_unweighted-fst.lo +compact8_unweighted_fst_la_OBJECTS = \ + $(am_compact8_unweighted_fst_la_OBJECTS) +compact8_unweighted_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) \ + $(compact8_unweighted_fst_la_LDFLAGS) $(LDFLAGS) -o $@ +compact8_unweighted_acceptor_fst_la_LIBADD = +am_compact8_unweighted_acceptor_fst_la_OBJECTS = \ + compact8_unweighted_acceptor-fst.lo +compact8_unweighted_acceptor_fst_la_OBJECTS = \ + $(am_compact8_unweighted_acceptor_fst_la_OBJECTS) +compact8_unweighted_acceptor_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) \ + --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link \ + $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) \ + $(compact8_unweighted_acceptor_fst_la_LDFLAGS) $(LDFLAGS) -o \ + $@ +compact8_weighted_string_fst_la_LIBADD = +am_compact8_weighted_string_fst_la_OBJECTS = \ + compact8_weighted_string-fst.lo +compact8_weighted_string_fst_la_OBJECTS = \ + $(am_compact8_weighted_string_fst_la_OBJECTS) +compact8_weighted_string_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) \ + $(compact8_weighted_string_fst_la_LDFLAGS) $(LDFLAGS) -o $@ +am__DEPENDENCIES_1 = +libfstcompact_la_DEPENDENCIES = ../../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am_libfstcompact_la_OBJECTS = compact8_acceptor-fst.lo \ + compact8_string-fst.lo compact8_unweighted-fst.lo \ + compact8_unweighted_acceptor-fst.lo \ + compact8_weighted_string-fst.lo compact16_acceptor-fst.lo \ + compact16_string-fst.lo compact16_unweighted-fst.lo \ + compact16_unweighted_acceptor-fst.lo \ + compact16_weighted_string-fst.lo compact64_acceptor-fst.lo \ + compact64_string-fst.lo compact64_unweighted-fst.lo \ + compact64_unweighted_acceptor-fst.lo \ + compact64_weighted_string-fst.lo +libfstcompact_la_OBJECTS = $(am_libfstcompact_la_OBJECTS) +libfstcompact_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) $(libfstcompact_la_LDFLAGS) \ + $(LDFLAGS) -o $@ +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +DEFAULT_INCLUDES = +depcomp = $(SHELL) $(top_srcdir)/depcomp +am__depfiles_maybe = depfiles +am__mv = mv -f +CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CXXFLAGS) $(CXXFLAGS) +AM_V_CXX = $(am__v_CXX_@AM_V@) +am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@) +am__v_CXX_0 = @echo " CXX " $@; +am__v_CXX_1 = +CXXLD = $(CXX) +CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_CXXLD = $(am__v_CXXLD_@AM_V@) +am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@) +am__v_CXXLD_0 = @echo " CXXLD " $@; +am__v_CXXLD_1 = +SOURCES = $(compact16_acceptor_fst_la_SOURCES) \ + $(compact16_string_fst_la_SOURCES) \ + $(compact16_unweighted_fst_la_SOURCES) \ + $(compact16_unweighted_acceptor_fst_la_SOURCES) \ + $(compact16_weighted_string_fst_la_SOURCES) \ + $(compact64_acceptor_fst_la_SOURCES) \ + $(compact64_string_fst_la_SOURCES) \ + $(compact64_unweighted_fst_la_SOURCES) \ + $(compact64_unweighted_acceptor_fst_la_SOURCES) \ + $(compact64_weighted_string_fst_la_SOURCES) \ + $(compact8_acceptor_fst_la_SOURCES) \ + $(compact8_string_fst_la_SOURCES) \ + $(compact8_unweighted_fst_la_SOURCES) \ + $(compact8_unweighted_acceptor_fst_la_SOURCES) \ + $(compact8_weighted_string_fst_la_SOURCES) \ + $(libfstcompact_la_SOURCES) +DIST_SOURCES = $(compact16_acceptor_fst_la_SOURCES) \ + $(compact16_string_fst_la_SOURCES) \ + $(compact16_unweighted_fst_la_SOURCES) \ + $(compact16_unweighted_acceptor_fst_la_SOURCES) \ + $(compact16_weighted_string_fst_la_SOURCES) \ + $(compact64_acceptor_fst_la_SOURCES) \ + $(compact64_string_fst_la_SOURCES) \ + $(compact64_unweighted_fst_la_SOURCES) \ + $(compact64_unweighted_acceptor_fst_la_SOURCES) \ + $(compact64_weighted_string_fst_la_SOURCES) \ + $(compact8_acceptor_fst_la_SOURCES) \ + $(compact8_string_fst_la_SOURCES) \ + $(compact8_unweighted_fst_la_SOURCES) \ + $(compact8_unweighted_acceptor_fst_la_SOURCES) \ + $(compact8_weighted_string_fst_la_SOURCES) \ + $(libfstcompact_la_SOURCES) +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DL_LIBS = @DL_LIBS@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PYTHON = @PYTHON@ +PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@ +PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ +PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@ +PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@ +PYTHON_LDFLAGS = @PYTHON_LDFLAGS@ +PYTHON_PLATFORM = @PYTHON_PLATFORM@ +PYTHON_PREFIX = @PYTHON_PREFIX@ +PYTHON_SITE_PKG = @PYTHON_SITE_PKG@ +PYTHON_VERSION = @PYTHON_VERSION@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +libfstdir = @libfstdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgpyexecdir = @pkgpyexecdir@ +pkgpythondir = @pkgpythondir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +pyexecdir = @pyexecdir@ +pythondir = @pythondir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) +libfst_LTLIBRARIES = compact8_acceptor-fst.la compact8_string-fst.la compact8_unweighted-fst.la compact8_unweighted_acceptor-fst.la compact8_weighted_string-fst.la compact16_acceptor-fst.la compact16_string-fst.la compact16_unweighted-fst.la compact16_unweighted_acceptor-fst.la compact16_weighted_string-fst.la compact64_acceptor-fst.la compact64_string-fst.la compact64_unweighted-fst.la compact64_unweighted_acceptor-fst.la compact64_weighted_string-fst.la +lib_LTLIBRARIES = libfstcompact.la +libfstcompact_la_SOURCES = compact8_acceptor-fst.cc compact8_string-fst.cc compact8_unweighted-fst.cc compact8_unweighted_acceptor-fst.cc compact8_weighted_string-fst.cc compact16_acceptor-fst.cc compact16_string-fst.cc compact16_unweighted-fst.cc compact16_unweighted_acceptor-fst.cc compact16_weighted_string-fst.cc compact64_acceptor-fst.cc compact64_string-fst.cc compact64_unweighted-fst.cc compact64_unweighted_acceptor-fst.cc compact64_weighted_string-fst.cc +libfstcompact_la_LDFLAGS = -version-info 10:0:0 +libfstcompact_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS) +compact8_acceptor_fst_la_SOURCES = compact8_acceptor-fst.cc +compact8_acceptor_fst_la_LDFLAGS = -module +compact8_string_fst_la_SOURCES = compact8_string-fst.cc +compact8_string_fst_la_LDFLAGS = -module +compact8_unweighted_fst_la_SOURCES = compact8_unweighted-fst.cc +compact8_unweighted_fst_la_LDFLAGS = -module +compact8_unweighted_acceptor_fst_la_SOURCES = compact8_unweighted_acceptor-fst.cc +compact8_unweighted_acceptor_fst_la_LDFLAGS = -module +compact8_weighted_string_fst_la_SOURCES = compact8_weighted_string-fst.cc +compact8_weighted_string_fst_la_LDFLAGS = -module +compact16_acceptor_fst_la_SOURCES = compact16_acceptor-fst.cc +compact16_acceptor_fst_la_LDFLAGS = -module +compact16_string_fst_la_SOURCES = compact16_string-fst.cc +compact16_string_fst_la_LDFLAGS = -module +compact16_unweighted_fst_la_SOURCES = compact16_unweighted-fst.cc +compact16_unweighted_fst_la_LDFLAGS = -module +compact16_unweighted_acceptor_fst_la_SOURCES = compact16_unweighted_acceptor-fst.cc +compact16_unweighted_acceptor_fst_la_LDFLAGS = -module +compact16_weighted_string_fst_la_SOURCES = compact16_weighted_string-fst.cc +compact16_weighted_string_fst_la_LDFLAGS = -module +compact64_acceptor_fst_la_SOURCES = compact64_acceptor-fst.cc +compact64_acceptor_fst_la_LDFLAGS = -module +compact64_string_fst_la_SOURCES = compact64_string-fst.cc +compact64_string_fst_la_LDFLAGS = -module +compact64_unweighted_fst_la_SOURCES = compact64_unweighted-fst.cc +compact64_unweighted_fst_la_LDFLAGS = -module +compact64_unweighted_acceptor_fst_la_SOURCES = compact64_unweighted_acceptor-fst.cc +compact64_unweighted_acceptor_fst_la_LDFLAGS = -module +compact64_weighted_string_fst_la_SOURCES = compact64_weighted_string-fst.cc +compact64_weighted_string_fst_la_LDFLAGS = -module +all: all-am + +.SUFFIXES: +.SUFFIXES: .cc .lo .o .obj +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/compact/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign src/extensions/compact/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +install-libLTLIBRARIES: $(lib_LTLIBRARIES) + @$(NORMAL_INSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \ + } + +uninstall-libLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \ + done + +clean-libLTLIBRARIES: + -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES) + @list='$(lib_LTLIBRARIES)'; \ + locs=`for p in $$list; do echo $$p; done | \ + sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ + sort -u`; \ + test -z "$$locs" || { \ + echo rm -f $${locs}; \ + rm -f $${locs}; \ + } + +install-libfstLTLIBRARIES: $(libfst_LTLIBRARIES) + @$(NORMAL_INSTALL) + @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(libfstdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(libfstdir)" || exit 1; \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libfstdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libfstdir)"; \ + } + +uninstall-libfstLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libfstdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libfstdir)/$$f"; \ + done + +clean-libfstLTLIBRARIES: + -test -z "$(libfst_LTLIBRARIES)" || rm -f $(libfst_LTLIBRARIES) + @list='$(libfst_LTLIBRARIES)'; \ + locs=`for p in $$list; do echo $$p; done | \ + sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ + sort -u`; \ + test -z "$$locs" || { \ + echo rm -f $${locs}; \ + rm -f $${locs}; \ + } + +compact16_acceptor-fst.la: $(compact16_acceptor_fst_la_OBJECTS) $(compact16_acceptor_fst_la_DEPENDENCIES) $(EXTRA_compact16_acceptor_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(compact16_acceptor_fst_la_LINK) -rpath $(libfstdir) $(compact16_acceptor_fst_la_OBJECTS) $(compact16_acceptor_fst_la_LIBADD) $(LIBS) + +compact16_string-fst.la: $(compact16_string_fst_la_OBJECTS) $(compact16_string_fst_la_DEPENDENCIES) $(EXTRA_compact16_string_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(compact16_string_fst_la_LINK) -rpath $(libfstdir) $(compact16_string_fst_la_OBJECTS) $(compact16_string_fst_la_LIBADD) $(LIBS) + +compact16_unweighted-fst.la: $(compact16_unweighted_fst_la_OBJECTS) $(compact16_unweighted_fst_la_DEPENDENCIES) $(EXTRA_compact16_unweighted_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(compact16_unweighted_fst_la_LINK) -rpath $(libfstdir) $(compact16_unweighted_fst_la_OBJECTS) $(compact16_unweighted_fst_la_LIBADD) $(LIBS) + +compact16_unweighted_acceptor-fst.la: $(compact16_unweighted_acceptor_fst_la_OBJECTS) $(compact16_unweighted_acceptor_fst_la_DEPENDENCIES) $(EXTRA_compact16_unweighted_acceptor_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(compact16_unweighted_acceptor_fst_la_LINK) -rpath $(libfstdir) $(compact16_unweighted_acceptor_fst_la_OBJECTS) $(compact16_unweighted_acceptor_fst_la_LIBADD) $(LIBS) + +compact16_weighted_string-fst.la: $(compact16_weighted_string_fst_la_OBJECTS) $(compact16_weighted_string_fst_la_DEPENDENCIES) $(EXTRA_compact16_weighted_string_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(compact16_weighted_string_fst_la_LINK) -rpath $(libfstdir) $(compact16_weighted_string_fst_la_OBJECTS) $(compact16_weighted_string_fst_la_LIBADD) $(LIBS) + +compact64_acceptor-fst.la: $(compact64_acceptor_fst_la_OBJECTS) $(compact64_acceptor_fst_la_DEPENDENCIES) $(EXTRA_compact64_acceptor_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(compact64_acceptor_fst_la_LINK) -rpath $(libfstdir) $(compact64_acceptor_fst_la_OBJECTS) $(compact64_acceptor_fst_la_LIBADD) $(LIBS) + +compact64_string-fst.la: $(compact64_string_fst_la_OBJECTS) $(compact64_string_fst_la_DEPENDENCIES) $(EXTRA_compact64_string_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(compact64_string_fst_la_LINK) -rpath $(libfstdir) $(compact64_string_fst_la_OBJECTS) $(compact64_string_fst_la_LIBADD) $(LIBS) + +compact64_unweighted-fst.la: $(compact64_unweighted_fst_la_OBJECTS) $(compact64_unweighted_fst_la_DEPENDENCIES) $(EXTRA_compact64_unweighted_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(compact64_unweighted_fst_la_LINK) -rpath $(libfstdir) $(compact64_unweighted_fst_la_OBJECTS) $(compact64_unweighted_fst_la_LIBADD) $(LIBS) + +compact64_unweighted_acceptor-fst.la: $(compact64_unweighted_acceptor_fst_la_OBJECTS) $(compact64_unweighted_acceptor_fst_la_DEPENDENCIES) $(EXTRA_compact64_unweighted_acceptor_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(compact64_unweighted_acceptor_fst_la_LINK) -rpath $(libfstdir) $(compact64_unweighted_acceptor_fst_la_OBJECTS) $(compact64_unweighted_acceptor_fst_la_LIBADD) $(LIBS) + +compact64_weighted_string-fst.la: $(compact64_weighted_string_fst_la_OBJECTS) $(compact64_weighted_string_fst_la_DEPENDENCIES) $(EXTRA_compact64_weighted_string_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(compact64_weighted_string_fst_la_LINK) -rpath $(libfstdir) $(compact64_weighted_string_fst_la_OBJECTS) $(compact64_weighted_string_fst_la_LIBADD) $(LIBS) + +compact8_acceptor-fst.la: $(compact8_acceptor_fst_la_OBJECTS) $(compact8_acceptor_fst_la_DEPENDENCIES) $(EXTRA_compact8_acceptor_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(compact8_acceptor_fst_la_LINK) -rpath $(libfstdir) $(compact8_acceptor_fst_la_OBJECTS) $(compact8_acceptor_fst_la_LIBADD) $(LIBS) + +compact8_string-fst.la: $(compact8_string_fst_la_OBJECTS) $(compact8_string_fst_la_DEPENDENCIES) $(EXTRA_compact8_string_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(compact8_string_fst_la_LINK) -rpath $(libfstdir) $(compact8_string_fst_la_OBJECTS) $(compact8_string_fst_la_LIBADD) $(LIBS) + +compact8_unweighted-fst.la: $(compact8_unweighted_fst_la_OBJECTS) $(compact8_unweighted_fst_la_DEPENDENCIES) $(EXTRA_compact8_unweighted_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(compact8_unweighted_fst_la_LINK) -rpath $(libfstdir) $(compact8_unweighted_fst_la_OBJECTS) $(compact8_unweighted_fst_la_LIBADD) $(LIBS) + +compact8_unweighted_acceptor-fst.la: $(compact8_unweighted_acceptor_fst_la_OBJECTS) $(compact8_unweighted_acceptor_fst_la_DEPENDENCIES) $(EXTRA_compact8_unweighted_acceptor_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(compact8_unweighted_acceptor_fst_la_LINK) -rpath $(libfstdir) $(compact8_unweighted_acceptor_fst_la_OBJECTS) $(compact8_unweighted_acceptor_fst_la_LIBADD) $(LIBS) + +compact8_weighted_string-fst.la: $(compact8_weighted_string_fst_la_OBJECTS) $(compact8_weighted_string_fst_la_DEPENDENCIES) $(EXTRA_compact8_weighted_string_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(compact8_weighted_string_fst_la_LINK) -rpath $(libfstdir) $(compact8_weighted_string_fst_la_OBJECTS) $(compact8_weighted_string_fst_la_LIBADD) $(LIBS) + +libfstcompact.la: $(libfstcompact_la_OBJECTS) $(libfstcompact_la_DEPENDENCIES) $(EXTRA_libfstcompact_la_DEPENDENCIES) + $(AM_V_CXXLD)$(libfstcompact_la_LINK) -rpath $(libdir) $(libfstcompact_la_OBJECTS) $(libfstcompact_la_LIBADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact16_acceptor-fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact16_string-fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact16_unweighted-fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact16_unweighted_acceptor-fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact16_weighted_string-fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact64_acceptor-fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact64_string-fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact64_unweighted-fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact64_unweighted_acceptor-fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact64_weighted_string-fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact8_acceptor-fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact8_string-fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact8_unweighted-fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact8_unweighted_acceptor-fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact8_weighted_string-fst.Plo@am__quote@ + +.cc.o: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $< + +.cc.obj: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cc.lo: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ +@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $< + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-am +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-am + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscopelist: cscopelist-am + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(LTLIBRARIES) +installdirs: + for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic clean-libLTLIBRARIES clean-libfstLTLIBRARIES \ + clean-libtool mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: install-libfstLTLIBRARIES + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: install-libLTLIBRARIES + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-libLTLIBRARIES uninstall-libfstLTLIBRARIES + +.MAKE: install-am install-strip + +.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \ + clean-libLTLIBRARIES clean-libfstLTLIBRARIES clean-libtool \ + cscopelist-am ctags ctags-am distclean distclean-compile \ + distclean-generic distclean-libtool distclean-tags distdir dvi \ + dvi-am html html-am info info-am install install-am \ + install-data install-data-am install-dvi install-dvi-am \ + install-exec install-exec-am install-html install-html-am \ + install-info install-info-am install-libLTLIBRARIES \ + install-libfstLTLIBRARIES install-man install-pdf \ + install-pdf-am install-ps install-ps-am install-strip \ + installcheck installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-compile \ + mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ + tags tags-am uninstall uninstall-am uninstall-libLTLIBRARIES \ + uninstall-libfstLTLIBRARIES + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact16_acceptor-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact16_acceptor-fst.cc new file mode 100644 index 0000000000..de94d5df80 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact16_acceptor-fst.cc @@ -0,0 +1,14 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { + +static FstRegisterer> + CompactAcceptorFst_StdArc_uint16_registerer; +static FstRegisterer> + CompactAcceptorFst_LogArc_uint16_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact16_string-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact16_string-fst.cc new file mode 100644 index 0000000000..b3b4b2c1b9 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact16_string-fst.cc @@ -0,0 +1,14 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { + +static FstRegisterer> + CompactStringFst_StdArc_uint16_registerer; +static FstRegisterer> + CompactStringFst_LogArc_uint16_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact16_unweighted-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact16_unweighted-fst.cc new file mode 100644 index 0000000000..21fc247dcd --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact16_unweighted-fst.cc @@ -0,0 +1,14 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { + +static FstRegisterer> + CompactUnweightedFst_StdArc_uint16_registerer; +static FstRegisterer> + CompactUnweightedFst_LogArc_uint16_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact16_unweighted_acceptor-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact16_unweighted_acceptor-fst.cc new file mode 100644 index 0000000000..13cfb4d2f4 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact16_unweighted_acceptor-fst.cc @@ -0,0 +1,16 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { + +static FstRegisterer< + CompactUnweightedAcceptorFst> + CompactUnweightedAcceptorFst_StdArc_uint16_registerer; +static FstRegisterer< + CompactUnweightedAcceptorFst> + CompactUnweightedAcceptorFst_LogArc_uint16_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact16_weighted_string-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact16_weighted_string-fst.cc new file mode 100644 index 0000000000..baa99179b1 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact16_weighted_string-fst.cc @@ -0,0 +1,17 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { + +static FstRegisterer< + CompactWeightedStringFst> + CompactWeightedStringFst_StdArc_uint16_registerer; + +static FstRegisterer< + CompactWeightedStringFst> + CompactWeightedStringFst_LogArc_uint16_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact64_acceptor-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact64_acceptor-fst.cc new file mode 100644 index 0000000000..eb410b8ef7 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact64_acceptor-fst.cc @@ -0,0 +1,15 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { + +static FstRegisterer> + CompactAcceptorFst_StdArc_uint64_registerer; + +static FstRegisterer> + CompactAcceptorFst_LogArc_uint64_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact64_string-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact64_string-fst.cc new file mode 100644 index 0000000000..708be494b4 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact64_string-fst.cc @@ -0,0 +1,14 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { + +static FstRegisterer> + CompactStringFst_StdArc_uint64_registerer; +static FstRegisterer> + CompactStringFst_LogArc_uint64_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact64_unweighted-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact64_unweighted-fst.cc new file mode 100644 index 0000000000..01f6651920 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact64_unweighted-fst.cc @@ -0,0 +1,14 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { + +static FstRegisterer> + CompactUnweightedFst_StdArc_uint64_registerer; +static FstRegisterer> + CompactUnweightedFst_LogArc_uint64_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact64_unweighted_acceptor-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact64_unweighted_acceptor-fst.cc new file mode 100644 index 0000000000..f8f7b7067e --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact64_unweighted_acceptor-fst.cc @@ -0,0 +1,16 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { + +static FstRegisterer< + CompactUnweightedAcceptorFst> + CompactUnweightedAcceptorFst_StdArc_uint64_registerer; +static FstRegisterer< + CompactUnweightedAcceptorFst> + CompactUnweightedAcceptorFst_LogArc_uint64_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact64_weighted_string-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact64_weighted_string-fst.cc new file mode 100644 index 0000000000..4b439dc780 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact64_weighted_string-fst.cc @@ -0,0 +1,16 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { + +static FstRegisterer< + CompactWeightedStringFst> + CompactWeightedStringFst_StdArc_uint64_registerer; +static FstRegisterer< + CompactWeightedStringFst> + CompactWeightedStringFst_LogArc_uint64_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact8_acceptor-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact8_acceptor-fst.cc new file mode 100644 index 0000000000..5de2665d39 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact8_acceptor-fst.cc @@ -0,0 +1,14 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { + +static FstRegisterer> + CompactAcceptorFst_StdArc_uint8_registerer; +static FstRegisterer> + CompactAcceptorFst_LogArc_uint8_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact8_string-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact8_string-fst.cc new file mode 100644 index 0000000000..384875b9c4 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact8_string-fst.cc @@ -0,0 +1,14 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { + +static FstRegisterer> + CompactStringFst_StdArc_uint8_registerer; +static FstRegisterer> + CompactStringFst_LogArc_uint8_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact8_unweighted-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact8_unweighted-fst.cc new file mode 100644 index 0000000000..7769096f78 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact8_unweighted-fst.cc @@ -0,0 +1,14 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { + +static FstRegisterer> + CompactUnweightedFst_StdArc_uint8_registerer; +static FstRegisterer> + CompactUnweightedFst_LogArc_uint8_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact8_unweighted_acceptor-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact8_unweighted_acceptor-fst.cc new file mode 100644 index 0000000000..26d04836e8 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact8_unweighted_acceptor-fst.cc @@ -0,0 +1,16 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { + +static FstRegisterer< + CompactUnweightedAcceptorFst> + CompactUnweightedAcceptorFst_StdArc_uint8_registerer; +static FstRegisterer< + CompactUnweightedAcceptorFst> + CompactUnweightedAcceptorFst_LogArc_uint8_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact8_weighted_string-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact8_weighted_string-fst.cc new file mode 100644 index 0000000000..850685996e --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compact/compact8_weighted_string-fst.cc @@ -0,0 +1,16 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { + +static FstRegisterer< + CompactWeightedStringFst> + CompactWeightedStringFst_StdArc_uint8_registerer; +static FstRegisterer< + CompactWeightedStringFst> + CompactWeightedStringFst_LogArc_uint8_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compress/Makefile.am b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compress/Makefile.am new file mode 100644 index 0000000000..56d66ebf11 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compress/Makefile.am @@ -0,0 +1,25 @@ +AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) + +if HAVE_BIN +bin_PROGRAMS = fstcompress fstrandmod + +LDADD = libfstcompressscript.la \ + ../../script/libfstscript.la \ + ../../lib/libfst.la \ + -lm $(DL_LIBS) + +fstcompress_SOURCES = fstcompress.cc +fstrandmod_SOURCES = fstrandmod.cc +endif + +if HAVE_SCRIPT +libfstcompressscript_la_SOURCES = compress-script.cc +libfstcompressscript_la_LDFLAGS = -version-info 10:0:0 +libfstcompressscript_la_LIBADD = \ + ../../script/libfstscript.la \ + ../../lib/libfst.la -lz -lm $(DL_LIBS) +endif + +if HAVE_SCRIPT +lib_LTLIBRARIES = libfstcompressscript.la +endif diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compress/Makefile.in b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compress/Makefile.in new file mode 100644 index 0000000000..f3f09553ed --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compress/Makefile.in @@ -0,0 +1,756 @@ +# Makefile.in generated by automake 1.14.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2013 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + + +VPATH = @srcdir@ +am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +@HAVE_BIN_TRUE@bin_PROGRAMS = fstcompress$(EXEEXT) fstrandmod$(EXEEXT) +subdir = src/extensions/compress +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ + $(top_srcdir)/depcomp +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \ + $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ + $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ + $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h \ + $(top_builddir)/src/include/fst/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__uninstall_files_from_dir = { \ + test -z "$$files" \ + || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && rm -f $$files; }; \ + } +am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(bindir)" +LTLIBRARIES = $(lib_LTLIBRARIES) +am__DEPENDENCIES_1 = +@HAVE_SCRIPT_TRUE@libfstcompressscript_la_DEPENDENCIES = \ +@HAVE_SCRIPT_TRUE@ ../../script/libfstscript.la \ +@HAVE_SCRIPT_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +am__libfstcompressscript_la_SOURCES_DIST = compress-script.cc +@HAVE_SCRIPT_TRUE@am_libfstcompressscript_la_OBJECTS = \ +@HAVE_SCRIPT_TRUE@ compress-script.lo +libfstcompressscript_la_OBJECTS = \ + $(am_libfstcompressscript_la_OBJECTS) +AM_V_lt = $(am__v_lt_@AM_V@) +am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) +am__v_lt_0 = --silent +am__v_lt_1 = +libfstcompressscript_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) $(libfstcompressscript_la_LDFLAGS) \ + $(LDFLAGS) -o $@ +@HAVE_SCRIPT_TRUE@am_libfstcompressscript_la_rpath = -rpath $(libdir) +PROGRAMS = $(bin_PROGRAMS) +am__fstcompress_SOURCES_DIST = fstcompress.cc +@HAVE_BIN_TRUE@am_fstcompress_OBJECTS = fstcompress.$(OBJEXT) +fstcompress_OBJECTS = $(am_fstcompress_OBJECTS) +fstcompress_LDADD = $(LDADD) +@HAVE_BIN_TRUE@fstcompress_DEPENDENCIES = libfstcompressscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +am__fstrandmod_SOURCES_DIST = fstrandmod.cc +@HAVE_BIN_TRUE@am_fstrandmod_OBJECTS = fstrandmod.$(OBJEXT) +fstrandmod_OBJECTS = $(am_fstrandmod_OBJECTS) +fstrandmod_LDADD = $(LDADD) +@HAVE_BIN_TRUE@fstrandmod_DEPENDENCIES = libfstcompressscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +DEFAULT_INCLUDES = +depcomp = $(SHELL) $(top_srcdir)/depcomp +am__depfiles_maybe = depfiles +am__mv = mv -f +CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CXXFLAGS) $(CXXFLAGS) +AM_V_CXX = $(am__v_CXX_@AM_V@) +am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@) +am__v_CXX_0 = @echo " CXX " $@; +am__v_CXX_1 = +CXXLD = $(CXX) +CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_CXXLD = $(am__v_CXXLD_@AM_V@) +am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@) +am__v_CXXLD_0 = @echo " CXXLD " $@; +am__v_CXXLD_1 = +SOURCES = $(libfstcompressscript_la_SOURCES) $(fstcompress_SOURCES) \ + $(fstrandmod_SOURCES) +DIST_SOURCES = $(am__libfstcompressscript_la_SOURCES_DIST) \ + $(am__fstcompress_SOURCES_DIST) $(am__fstrandmod_SOURCES_DIST) +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DL_LIBS = @DL_LIBS@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PYTHON = @PYTHON@ +PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@ +PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ +PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@ +PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@ +PYTHON_LDFLAGS = @PYTHON_LDFLAGS@ +PYTHON_PLATFORM = @PYTHON_PLATFORM@ +PYTHON_PREFIX = @PYTHON_PREFIX@ +PYTHON_SITE_PKG = @PYTHON_SITE_PKG@ +PYTHON_VERSION = @PYTHON_VERSION@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +libfstdir = @libfstdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgpyexecdir = @pkgpyexecdir@ +pkgpythondir = @pkgpythondir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +pyexecdir = @pyexecdir@ +pythondir = @pythondir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) +@HAVE_BIN_TRUE@LDADD = libfstcompressscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la \ +@HAVE_BIN_TRUE@ -lm $(DL_LIBS) + +@HAVE_BIN_TRUE@fstcompress_SOURCES = fstcompress.cc +@HAVE_BIN_TRUE@fstrandmod_SOURCES = fstrandmod.cc +@HAVE_SCRIPT_TRUE@libfstcompressscript_la_SOURCES = compress-script.cc +@HAVE_SCRIPT_TRUE@libfstcompressscript_la_LDFLAGS = -version-info 10:0:0 +@HAVE_SCRIPT_TRUE@libfstcompressscript_la_LIBADD = \ +@HAVE_SCRIPT_TRUE@ ../../script/libfstscript.la \ +@HAVE_SCRIPT_TRUE@ ../../lib/libfst.la -lz -lm $(DL_LIBS) + +@HAVE_SCRIPT_TRUE@lib_LTLIBRARIES = libfstcompressscript.la +all: all-am + +.SUFFIXES: +.SUFFIXES: .cc .lo .o .obj +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/compress/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign src/extensions/compress/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +install-libLTLIBRARIES: $(lib_LTLIBRARIES) + @$(NORMAL_INSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \ + } + +uninstall-libLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \ + done + +clean-libLTLIBRARIES: + -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES) + @list='$(lib_LTLIBRARIES)'; \ + locs=`for p in $$list; do echo $$p; done | \ + sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ + sort -u`; \ + test -z "$$locs" || { \ + echo rm -f $${locs}; \ + rm -f $${locs}; \ + } + +libfstcompressscript.la: $(libfstcompressscript_la_OBJECTS) $(libfstcompressscript_la_DEPENDENCIES) $(EXTRA_libfstcompressscript_la_DEPENDENCIES) + $(AM_V_CXXLD)$(libfstcompressscript_la_LINK) $(am_libfstcompressscript_la_rpath) $(libfstcompressscript_la_OBJECTS) $(libfstcompressscript_la_LIBADD) $(LIBS) +install-binPROGRAMS: $(bin_PROGRAMS) + @$(NORMAL_INSTALL) + @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \ + if test -n "$$list"; then \ + echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \ + fi; \ + for p in $$list; do echo "$$p $$p"; done | \ + sed 's/$(EXEEXT)$$//' | \ + while read p p1; do if test -f $$p \ + || test -f $$p1 \ + ; then echo "$$p"; echo "$$p"; else :; fi; \ + done | \ + sed -e 'p;s,.*/,,;n;h' \ + -e 's|.*|.|' \ + -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \ + sed 'N;N;N;s,\n, ,g' | \ + $(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \ + { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \ + if ($$2 == $$4) files[d] = files[d] " " $$1; \ + else { print "f", $$3 "/" $$4, $$1; } } \ + END { for (d in files) print "f", d, files[d] }' | \ + while read type dir files; do \ + if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \ + test -z "$$files" || { \ + echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \ + $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \ + } \ + ; done + +uninstall-binPROGRAMS: + @$(NORMAL_UNINSTALL) + @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \ + files=`for p in $$list; do echo "$$p"; done | \ + sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \ + -e 's/$$/$(EXEEXT)/' \ + `; \ + test -n "$$list" || exit 0; \ + echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(bindir)" && rm -f $$files + +clean-binPROGRAMS: + @list='$(bin_PROGRAMS)'; test -n "$$list" || exit 0; \ + echo " rm -f" $$list; \ + rm -f $$list || exit $$?; \ + test -n "$(EXEEXT)" || exit 0; \ + list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \ + echo " rm -f" $$list; \ + rm -f $$list + +fstcompress$(EXEEXT): $(fstcompress_OBJECTS) $(fstcompress_DEPENDENCIES) $(EXTRA_fstcompress_DEPENDENCIES) + @rm -f fstcompress$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstcompress_OBJECTS) $(fstcompress_LDADD) $(LIBS) + +fstrandmod$(EXEEXT): $(fstrandmod_OBJECTS) $(fstrandmod_DEPENDENCIES) $(EXTRA_fstrandmod_DEPENDENCIES) + @rm -f fstrandmod$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstrandmod_OBJECTS) $(fstrandmod_LDADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compress-script.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstcompress.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstrandmod.Po@am__quote@ + +.cc.o: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $< + +.cc.obj: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cc.lo: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ +@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $< + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-am +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-am + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscopelist: cscopelist-am + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(LTLIBRARIES) $(PROGRAMS) +install-binPROGRAMS: install-libLTLIBRARIES + +installdirs: + for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(bindir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \ + clean-libtool mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: install-binPROGRAMS install-libLTLIBRARIES + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-binPROGRAMS uninstall-libLTLIBRARIES + +.MAKE: install-am install-strip + +.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \ + clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \ + clean-libtool cscopelist-am ctags ctags-am distclean \ + distclean-compile distclean-generic distclean-libtool \ + distclean-tags distdir dvi dvi-am html html-am info info-am \ + install install-am install-binPROGRAMS install-data \ + install-data-am install-dvi install-dvi-am install-exec \ + install-exec-am install-html install-html-am install-info \ + install-info-am install-libLTLIBRARIES install-man install-pdf \ + install-pdf-am install-ps install-ps-am install-strip \ + installcheck installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-compile \ + mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ + tags tags-am uninstall uninstall-am uninstall-binPROGRAMS \ + uninstall-libLTLIBRARIES + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compress/compress-script.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compress/compress-script.cc new file mode 100644 index 0000000000..ad4c7fda27 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compress/compress-script.cc @@ -0,0 +1,41 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Definitions of 'scriptable' versions of compression operations, that is, +// those that can be called with FstClass-type arguments. +// +// See comments in nlp/fst/script/script-impl.h for how the registration +// mechanism allows these to work with various arc types. + +#include +#include + +#include + +#include + +namespace fst { +namespace script { + +void Compress(const FstClass &fst, const string &filename, const bool gzip) { + CompressArgs args(fst, filename, gzip); + Apply>("Compress", fst.ArcType(), &args); +} + +void Decompress(const string &filename, MutableFstClass *fst, const bool gzip) { + DecompressArgs args(filename, fst, gzip); + Apply>("Decompress", fst->ArcType(), &args); +} + +// Register operations for common arc types. + +REGISTER_FST_OPERATION(Compress, StdArc, CompressArgs); +REGISTER_FST_OPERATION(Compress, LogArc, CompressArgs); +REGISTER_FST_OPERATION(Compress, Log64Arc, CompressArgs); + +REGISTER_FST_OPERATION(Decompress, StdArc, DecompressArgs); +REGISTER_FST_OPERATION(Decompress, LogArc, DecompressArgs); +REGISTER_FST_OPERATION(Decompress, Log64Arc, DecompressArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compress/fstcompress.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compress/fstcompress.cc new file mode 100644 index 0000000000..b68020f3bb --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compress/fstcompress.cc @@ -0,0 +1,55 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Compresses/decompresses an FST. + +#include +#include + +#include + +#include +#include +#include +#include + +DEFINE_string(arc_type, "standard", "Output arc type"); +DEFINE_bool(decode, false, "Decode"); +DEFINE_bool(gzip, false, + "Applies gzip compression after LZA compression and " + "gzip decompression before LZA decompression " + "(recommended)" + ""); + +int main(int argc, char **argv) { + namespace s = fst::script; + + using s::FstClass; + using s::VectorFstClass; + + string usage = "Compresses/decompresses an FST.\n\n Usage: "; + usage += argv[0]; + usage += " [in.fst [out.fstz]]\n"; + usage += " --decode [in.fstz [out.fst]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + string in_name = (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : ""; + string out_name = argc > 2 ? argv[2] : ""; + + if (FLAGS_decode == false) { + std::unique_ptr ifst(FstClass::Read(in_name)); + if (!ifst) return 1; + s::Compress(*ifst, out_name, FLAGS_gzip); + } else { + VectorFstClass ofst(FLAGS_arc_type); + s::Decompress(in_name, &ofst, FLAGS_gzip); + ofst.Write(out_name); + } + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compress/fstrandmod.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compress/fstrandmod.cc new file mode 100644 index 0000000000..34e0bd25db --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/compress/fstrandmod.cc @@ -0,0 +1,59 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Generates a random FST according to a class-specific transition model. + +#include +#include +#include +#include + +#include + +#include +#include +#include +#include + +DEFINE_int32(seed, time(0), "Random seed"); +DEFINE_int32(states, 10, "# of states"); +DEFINE_int32(labels, 2, "# of labels"); +DEFINE_int32(classes, 1, "# of probability distributions"); +DEFINE_bool(transducer, false, "Output a transducer"); +DEFINE_bool(weights, false, "Output a weighted FST"); + +int main(int argc, char **argv) { + using fst::StdVectorFst; + using fst::StdArc; + using fst::TropicalWeight; + using fst::WeightGenerate; + + string usage = "Generates a random FST.\n\n Usage: "; + usage += argv[0]; + usage += "[out.fst]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 2) { + ShowUsage(); + return 1; + } + + string out_name = (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : ""; + + srand(FLAGS_seed); + + int num_states = (rand() % FLAGS_states) + 1; // NOLINT + int num_classes = (rand() % FLAGS_classes) + 1; // NOLINT + int num_labels = (rand() % FLAGS_labels) + 1; // NOLINT + + StdVectorFst fst; + using TropicalWeightGenerate = WeightGenerate; + std::unique_ptr generate(FLAGS_weights ? + new TropicalWeightGenerate(false) : nullptr); + fst::RandMod rand_mod(num_states, + num_classes, num_labels, FLAGS_transducer, generate.get()); + rand_mod.Generate(&fst); + fst.Write(out_name); + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/const/Makefile.am b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/const/Makefile.am new file mode 100644 index 0000000000..012ee47092 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/const/Makefile.am @@ -0,0 +1,19 @@ +AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) + +libfstdir = @libfstdir@ +libfst_LTLIBRARIES = const8-fst.la const16-fst.la const64-fst.la + +lib_LTLIBRARIES = libfstconst.la + +libfstconst_la_SOURCES = const8-fst.cc const16-fst.cc const64-fst.cc +libfstconst_la_LDFLAGS = -version-info 10:0:0 -lm $(DL_LIBS) +libfstconst_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS) + +const8_fst_la_SOURCES = const8-fst.cc +const8_fst_la_LDFLAGS = -module + +const16_fst_la_SOURCES = const16-fst.cc +const16_fst_la_LDFLAGS = -module + +const64_fst_la_SOURCES = const64-fst.cc +const64_fst_la_LDFLAGS = -module diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/const/Makefile.in b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/const/Makefile.in new file mode 100644 index 0000000000..3fc0617e5a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/const/Makefile.in @@ -0,0 +1,738 @@ +# Makefile.in generated by automake 1.14.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2013 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +VPATH = @srcdir@ +am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +subdir = src/extensions/const +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ + $(top_srcdir)/depcomp +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \ + $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ + $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ + $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h \ + $(top_builddir)/src/include/fst/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__uninstall_files_from_dir = { \ + test -z "$$files" \ + || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && rm -f $$files; }; \ + } +am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)" +LTLIBRARIES = $(lib_LTLIBRARIES) $(libfst_LTLIBRARIES) +const16_fst_la_LIBADD = +am_const16_fst_la_OBJECTS = const16-fst.lo +const16_fst_la_OBJECTS = $(am_const16_fst_la_OBJECTS) +AM_V_lt = $(am__v_lt_@AM_V@) +am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) +am__v_lt_0 = --silent +am__v_lt_1 = +const16_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) $(const16_fst_la_LDFLAGS) \ + $(LDFLAGS) -o $@ +const64_fst_la_LIBADD = +am_const64_fst_la_OBJECTS = const64-fst.lo +const64_fst_la_OBJECTS = $(am_const64_fst_la_OBJECTS) +const64_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) $(const64_fst_la_LDFLAGS) \ + $(LDFLAGS) -o $@ +const8_fst_la_LIBADD = +am_const8_fst_la_OBJECTS = const8-fst.lo +const8_fst_la_OBJECTS = $(am_const8_fst_la_OBJECTS) +const8_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) $(const8_fst_la_LDFLAGS) $(LDFLAGS) \ + -o $@ +am__DEPENDENCIES_1 = +libfstconst_la_DEPENDENCIES = ../../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am_libfstconst_la_OBJECTS = const8-fst.lo const16-fst.lo \ + const64-fst.lo +libfstconst_la_OBJECTS = $(am_libfstconst_la_OBJECTS) +libfstconst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) $(libfstconst_la_LDFLAGS) \ + $(LDFLAGS) -o $@ +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +DEFAULT_INCLUDES = +depcomp = $(SHELL) $(top_srcdir)/depcomp +am__depfiles_maybe = depfiles +am__mv = mv -f +CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CXXFLAGS) $(CXXFLAGS) +AM_V_CXX = $(am__v_CXX_@AM_V@) +am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@) +am__v_CXX_0 = @echo " CXX " $@; +am__v_CXX_1 = +CXXLD = $(CXX) +CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_CXXLD = $(am__v_CXXLD_@AM_V@) +am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@) +am__v_CXXLD_0 = @echo " CXXLD " $@; +am__v_CXXLD_1 = +SOURCES = $(const16_fst_la_SOURCES) $(const64_fst_la_SOURCES) \ + $(const8_fst_la_SOURCES) $(libfstconst_la_SOURCES) +DIST_SOURCES = $(const16_fst_la_SOURCES) $(const64_fst_la_SOURCES) \ + $(const8_fst_la_SOURCES) $(libfstconst_la_SOURCES) +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DL_LIBS = @DL_LIBS@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PYTHON = @PYTHON@ +PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@ +PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ +PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@ +PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@ +PYTHON_LDFLAGS = @PYTHON_LDFLAGS@ +PYTHON_PLATFORM = @PYTHON_PLATFORM@ +PYTHON_PREFIX = @PYTHON_PREFIX@ +PYTHON_SITE_PKG = @PYTHON_SITE_PKG@ +PYTHON_VERSION = @PYTHON_VERSION@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +libfstdir = @libfstdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgpyexecdir = @pkgpyexecdir@ +pkgpythondir = @pkgpythondir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +pyexecdir = @pyexecdir@ +pythondir = @pythondir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) +libfst_LTLIBRARIES = const8-fst.la const16-fst.la const64-fst.la +lib_LTLIBRARIES = libfstconst.la +libfstconst_la_SOURCES = const8-fst.cc const16-fst.cc const64-fst.cc +libfstconst_la_LDFLAGS = -version-info 10:0:0 -lm $(DL_LIBS) +libfstconst_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS) +const8_fst_la_SOURCES = const8-fst.cc +const8_fst_la_LDFLAGS = -module +const16_fst_la_SOURCES = const16-fst.cc +const16_fst_la_LDFLAGS = -module +const64_fst_la_SOURCES = const64-fst.cc +const64_fst_la_LDFLAGS = -module +all: all-am + +.SUFFIXES: +.SUFFIXES: .cc .lo .o .obj +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/const/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign src/extensions/const/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +install-libLTLIBRARIES: $(lib_LTLIBRARIES) + @$(NORMAL_INSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \ + } + +uninstall-libLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \ + done + +clean-libLTLIBRARIES: + -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES) + @list='$(lib_LTLIBRARIES)'; \ + locs=`for p in $$list; do echo $$p; done | \ + sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ + sort -u`; \ + test -z "$$locs" || { \ + echo rm -f $${locs}; \ + rm -f $${locs}; \ + } + +install-libfstLTLIBRARIES: $(libfst_LTLIBRARIES) + @$(NORMAL_INSTALL) + @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(libfstdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(libfstdir)" || exit 1; \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libfstdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libfstdir)"; \ + } + +uninstall-libfstLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libfstdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libfstdir)/$$f"; \ + done + +clean-libfstLTLIBRARIES: + -test -z "$(libfst_LTLIBRARIES)" || rm -f $(libfst_LTLIBRARIES) + @list='$(libfst_LTLIBRARIES)'; \ + locs=`for p in $$list; do echo $$p; done | \ + sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ + sort -u`; \ + test -z "$$locs" || { \ + echo rm -f $${locs}; \ + rm -f $${locs}; \ + } + +const16-fst.la: $(const16_fst_la_OBJECTS) $(const16_fst_la_DEPENDENCIES) $(EXTRA_const16_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(const16_fst_la_LINK) -rpath $(libfstdir) $(const16_fst_la_OBJECTS) $(const16_fst_la_LIBADD) $(LIBS) + +const64-fst.la: $(const64_fst_la_OBJECTS) $(const64_fst_la_DEPENDENCIES) $(EXTRA_const64_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(const64_fst_la_LINK) -rpath $(libfstdir) $(const64_fst_la_OBJECTS) $(const64_fst_la_LIBADD) $(LIBS) + +const8-fst.la: $(const8_fst_la_OBJECTS) $(const8_fst_la_DEPENDENCIES) $(EXTRA_const8_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(const8_fst_la_LINK) -rpath $(libfstdir) $(const8_fst_la_OBJECTS) $(const8_fst_la_LIBADD) $(LIBS) + +libfstconst.la: $(libfstconst_la_OBJECTS) $(libfstconst_la_DEPENDENCIES) $(EXTRA_libfstconst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(libfstconst_la_LINK) -rpath $(libdir) $(libfstconst_la_OBJECTS) $(libfstconst_la_LIBADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/const16-fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/const64-fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/const8-fst.Plo@am__quote@ + +.cc.o: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $< + +.cc.obj: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cc.lo: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ +@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $< + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-am +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-am + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscopelist: cscopelist-am + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(LTLIBRARIES) +installdirs: + for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic clean-libLTLIBRARIES clean-libfstLTLIBRARIES \ + clean-libtool mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: install-libfstLTLIBRARIES + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: install-libLTLIBRARIES + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-libLTLIBRARIES uninstall-libfstLTLIBRARIES + +.MAKE: install-am install-strip + +.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \ + clean-libLTLIBRARIES clean-libfstLTLIBRARIES clean-libtool \ + cscopelist-am ctags ctags-am distclean distclean-compile \ + distclean-generic distclean-libtool distclean-tags distdir dvi \ + dvi-am html html-am info info-am install install-am \ + install-data install-data-am install-dvi install-dvi-am \ + install-exec install-exec-am install-html install-html-am \ + install-info install-info-am install-libLTLIBRARIES \ + install-libfstLTLIBRARIES install-man install-pdf \ + install-pdf-am install-ps install-ps-am install-strip \ + installcheck installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-compile \ + mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ + tags tags-am uninstall uninstall-am uninstall-libLTLIBRARIES \ + uninstall-libfstLTLIBRARIES + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/const/const16-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/const/const16-fst.cc new file mode 100644 index 0000000000..b6859fbfeb --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/const/const16-fst.cc @@ -0,0 +1,16 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { + +static FstRegisterer> + ConstFst_StdArc_uint16_registerer; +static FstRegisterer> + ConstFst_LogArc_uint16_registerer; +static FstRegisterer> + ConstFst_Log64Arc_uint16_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/const/const64-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/const/const64-fst.cc new file mode 100644 index 0000000000..9f059bfaeb --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/const/const64-fst.cc @@ -0,0 +1,16 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { + +static FstRegisterer> + ConstFst_StdArc_uint64_registerer; +static FstRegisterer> + ConstFst_LogArc_uint64_registerer; +static FstRegisterer> + ConstFst_Log64Arc_uint64_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/const/const8-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/const/const8-fst.cc new file mode 100644 index 0000000000..04b8064dcf --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/const/const8-fst.cc @@ -0,0 +1,14 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { + +static FstRegisterer> ConstFst_StdArc_uint8_registerer; +static FstRegisterer> ConstFst_LogArc_uint8_registerer; +static FstRegisterer> + ConstFst_Log64Arc_uint8_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/Makefile.am b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/Makefile.am new file mode 100644 index 0000000000..0df448a17a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/Makefile.am @@ -0,0 +1,42 @@ +AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) + +if HAVE_SCRIPT +lib_LTLIBRARIES = libfstfar.la libfstfarscript.la +else +lib_LTLIBRARIES = libfstfar.la +endif + +libfstfar_la_SOURCES = sttable.cc stlist.cc +libfstfar_la_LDFLAGS = -version-info 10:0:0 +libfstfar_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS) + +if HAVE_SCRIPT +libfstfarscript_la_SOURCES = far-class.cc farscript.cc getters.cc script-impl.cc \ + strings.cc +libfstfarscript_la_LDFLAGS = -version-info 10:0:0 +libfstfarscript_la_LIBADD = \ + libfstfar.la ../../script/libfstscript.la \ + ../../lib/libfst.la -lm $(DL_LIBS) +endif + +if HAVE_BIN +bin_PROGRAMS = farcompilestrings farcreate farequal farextract farinfo \ + farisomorphic farprintstrings + +LDADD = libfstfarscript.la ../../script/libfstscript.la \ + ../../lib/libfst.la -lm $(DL_LIBS) + +farcompilestrings_SOURCES = farcompilestrings.cc + +farcreate_SOURCES = farcreate.cc + +farequal_SOURCES = farequal.cc + +farextract_SOURCES = farextract.cc + +farinfo_SOURCES = farinfo.cc + +farisomorphic_SOURCES = farisomorphic.cc + +farprintstrings_SOURCES = farprintstrings.cc +endif diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/Makefile.in b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/Makefile.in new file mode 100644 index 0000000000..227ea5b55c --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/Makefile.in @@ -0,0 +1,854 @@ +# Makefile.in generated by automake 1.14.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2013 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + + +VPATH = @srcdir@ +am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +@HAVE_BIN_TRUE@bin_PROGRAMS = farcompilestrings$(EXEEXT) \ +@HAVE_BIN_TRUE@ farcreate$(EXEEXT) farequal$(EXEEXT) \ +@HAVE_BIN_TRUE@ farextract$(EXEEXT) farinfo$(EXEEXT) \ +@HAVE_BIN_TRUE@ farisomorphic$(EXEEXT) farprintstrings$(EXEEXT) +subdir = src/extensions/far +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ + $(top_srcdir)/depcomp +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \ + $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ + $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ + $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h \ + $(top_builddir)/src/include/fst/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__uninstall_files_from_dir = { \ + test -z "$$files" \ + || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && rm -f $$files; }; \ + } +am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(bindir)" +LTLIBRARIES = $(lib_LTLIBRARIES) +am__DEPENDENCIES_1 = +libfstfar_la_DEPENDENCIES = ../../lib/libfst.la $(am__DEPENDENCIES_1) +am_libfstfar_la_OBJECTS = sttable.lo stlist.lo +libfstfar_la_OBJECTS = $(am_libfstfar_la_OBJECTS) +AM_V_lt = $(am__v_lt_@AM_V@) +am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) +am__v_lt_0 = --silent +am__v_lt_1 = +libfstfar_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(libfstfar_la_LDFLAGS) $(LDFLAGS) -o $@ +@HAVE_SCRIPT_FALSE@am_libfstfar_la_rpath = -rpath $(libdir) +@HAVE_SCRIPT_TRUE@am_libfstfar_la_rpath = -rpath $(libdir) +@HAVE_SCRIPT_TRUE@libfstfarscript_la_DEPENDENCIES = libfstfar.la \ +@HAVE_SCRIPT_TRUE@ ../../script/libfstscript.la \ +@HAVE_SCRIPT_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +am__libfstfarscript_la_SOURCES_DIST = far-class.cc farscript.cc \ + getters.cc script-impl.cc strings.cc +@HAVE_SCRIPT_TRUE@am_libfstfarscript_la_OBJECTS = far-class.lo \ +@HAVE_SCRIPT_TRUE@ farscript.lo getters.lo script-impl.lo \ +@HAVE_SCRIPT_TRUE@ strings.lo +libfstfarscript_la_OBJECTS = $(am_libfstfarscript_la_OBJECTS) +libfstfarscript_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) $(libfstfarscript_la_LDFLAGS) \ + $(LDFLAGS) -o $@ +@HAVE_SCRIPT_TRUE@am_libfstfarscript_la_rpath = -rpath $(libdir) +PROGRAMS = $(bin_PROGRAMS) +am__farcompilestrings_SOURCES_DIST = farcompilestrings.cc +@HAVE_BIN_TRUE@am_farcompilestrings_OBJECTS = \ +@HAVE_BIN_TRUE@ farcompilestrings.$(OBJEXT) +farcompilestrings_OBJECTS = $(am_farcompilestrings_OBJECTS) +farcompilestrings_LDADD = $(LDADD) +@HAVE_BIN_TRUE@farcompilestrings_DEPENDENCIES = libfstfarscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +am__farcreate_SOURCES_DIST = farcreate.cc +@HAVE_BIN_TRUE@am_farcreate_OBJECTS = farcreate.$(OBJEXT) +farcreate_OBJECTS = $(am_farcreate_OBJECTS) +farcreate_LDADD = $(LDADD) +@HAVE_BIN_TRUE@farcreate_DEPENDENCIES = libfstfarscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +am__farequal_SOURCES_DIST = farequal.cc +@HAVE_BIN_TRUE@am_farequal_OBJECTS = farequal.$(OBJEXT) +farequal_OBJECTS = $(am_farequal_OBJECTS) +farequal_LDADD = $(LDADD) +@HAVE_BIN_TRUE@farequal_DEPENDENCIES = libfstfarscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +am__farextract_SOURCES_DIST = farextract.cc +@HAVE_BIN_TRUE@am_farextract_OBJECTS = farextract.$(OBJEXT) +farextract_OBJECTS = $(am_farextract_OBJECTS) +farextract_LDADD = $(LDADD) +@HAVE_BIN_TRUE@farextract_DEPENDENCIES = libfstfarscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +am__farinfo_SOURCES_DIST = farinfo.cc +@HAVE_BIN_TRUE@am_farinfo_OBJECTS = farinfo.$(OBJEXT) +farinfo_OBJECTS = $(am_farinfo_OBJECTS) +farinfo_LDADD = $(LDADD) +@HAVE_BIN_TRUE@farinfo_DEPENDENCIES = libfstfarscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +am__farisomorphic_SOURCES_DIST = farisomorphic.cc +@HAVE_BIN_TRUE@am_farisomorphic_OBJECTS = farisomorphic.$(OBJEXT) +farisomorphic_OBJECTS = $(am_farisomorphic_OBJECTS) +farisomorphic_LDADD = $(LDADD) +@HAVE_BIN_TRUE@farisomorphic_DEPENDENCIES = libfstfarscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +am__farprintstrings_SOURCES_DIST = farprintstrings.cc +@HAVE_BIN_TRUE@am_farprintstrings_OBJECTS = farprintstrings.$(OBJEXT) +farprintstrings_OBJECTS = $(am_farprintstrings_OBJECTS) +farprintstrings_LDADD = $(LDADD) +@HAVE_BIN_TRUE@farprintstrings_DEPENDENCIES = libfstfarscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +DEFAULT_INCLUDES = +depcomp = $(SHELL) $(top_srcdir)/depcomp +am__depfiles_maybe = depfiles +am__mv = mv -f +CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CXXFLAGS) $(CXXFLAGS) +AM_V_CXX = $(am__v_CXX_@AM_V@) +am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@) +am__v_CXX_0 = @echo " CXX " $@; +am__v_CXX_1 = +CXXLD = $(CXX) +CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_CXXLD = $(am__v_CXXLD_@AM_V@) +am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@) +am__v_CXXLD_0 = @echo " CXXLD " $@; +am__v_CXXLD_1 = +SOURCES = $(libfstfar_la_SOURCES) $(libfstfarscript_la_SOURCES) \ + $(farcompilestrings_SOURCES) $(farcreate_SOURCES) \ + $(farequal_SOURCES) $(farextract_SOURCES) $(farinfo_SOURCES) \ + $(farisomorphic_SOURCES) $(farprintstrings_SOURCES) +DIST_SOURCES = $(libfstfar_la_SOURCES) \ + $(am__libfstfarscript_la_SOURCES_DIST) \ + $(am__farcompilestrings_SOURCES_DIST) \ + $(am__farcreate_SOURCES_DIST) $(am__farequal_SOURCES_DIST) \ + $(am__farextract_SOURCES_DIST) $(am__farinfo_SOURCES_DIST) \ + $(am__farisomorphic_SOURCES_DIST) \ + $(am__farprintstrings_SOURCES_DIST) +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DL_LIBS = @DL_LIBS@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PYTHON = @PYTHON@ +PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@ +PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ +PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@ +PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@ +PYTHON_LDFLAGS = @PYTHON_LDFLAGS@ +PYTHON_PLATFORM = @PYTHON_PLATFORM@ +PYTHON_PREFIX = @PYTHON_PREFIX@ +PYTHON_SITE_PKG = @PYTHON_SITE_PKG@ +PYTHON_VERSION = @PYTHON_VERSION@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +libfstdir = @libfstdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgpyexecdir = @pkgpyexecdir@ +pkgpythondir = @pkgpythondir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +pyexecdir = @pyexecdir@ +pythondir = @pythondir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) +@HAVE_SCRIPT_FALSE@lib_LTLIBRARIES = libfstfar.la +@HAVE_SCRIPT_TRUE@lib_LTLIBRARIES = libfstfar.la libfstfarscript.la +libfstfar_la_SOURCES = sttable.cc stlist.cc +libfstfar_la_LDFLAGS = -version-info 10:0:0 +libfstfar_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS) +@HAVE_SCRIPT_TRUE@libfstfarscript_la_SOURCES = far-class.cc farscript.cc getters.cc script-impl.cc \ +@HAVE_SCRIPT_TRUE@ strings.cc + +@HAVE_SCRIPT_TRUE@libfstfarscript_la_LDFLAGS = -version-info 10:0:0 +@HAVE_SCRIPT_TRUE@libfstfarscript_la_LIBADD = \ +@HAVE_SCRIPT_TRUE@ libfstfar.la ../../script/libfstscript.la \ +@HAVE_SCRIPT_TRUE@ ../../lib/libfst.la -lm $(DL_LIBS) + +@HAVE_BIN_TRUE@LDADD = libfstfarscript.la ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la -lm $(DL_LIBS) + +@HAVE_BIN_TRUE@farcompilestrings_SOURCES = farcompilestrings.cc +@HAVE_BIN_TRUE@farcreate_SOURCES = farcreate.cc +@HAVE_BIN_TRUE@farequal_SOURCES = farequal.cc +@HAVE_BIN_TRUE@farextract_SOURCES = farextract.cc +@HAVE_BIN_TRUE@farinfo_SOURCES = farinfo.cc +@HAVE_BIN_TRUE@farisomorphic_SOURCES = farisomorphic.cc +@HAVE_BIN_TRUE@farprintstrings_SOURCES = farprintstrings.cc +all: all-am + +.SUFFIXES: +.SUFFIXES: .cc .lo .o .obj +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/far/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign src/extensions/far/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +install-libLTLIBRARIES: $(lib_LTLIBRARIES) + @$(NORMAL_INSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \ + } + +uninstall-libLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \ + done + +clean-libLTLIBRARIES: + -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES) + @list='$(lib_LTLIBRARIES)'; \ + locs=`for p in $$list; do echo $$p; done | \ + sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ + sort -u`; \ + test -z "$$locs" || { \ + echo rm -f $${locs}; \ + rm -f $${locs}; \ + } + +libfstfar.la: $(libfstfar_la_OBJECTS) $(libfstfar_la_DEPENDENCIES) $(EXTRA_libfstfar_la_DEPENDENCIES) + $(AM_V_CXXLD)$(libfstfar_la_LINK) $(am_libfstfar_la_rpath) $(libfstfar_la_OBJECTS) $(libfstfar_la_LIBADD) $(LIBS) + +libfstfarscript.la: $(libfstfarscript_la_OBJECTS) $(libfstfarscript_la_DEPENDENCIES) $(EXTRA_libfstfarscript_la_DEPENDENCIES) + $(AM_V_CXXLD)$(libfstfarscript_la_LINK) $(am_libfstfarscript_la_rpath) $(libfstfarscript_la_OBJECTS) $(libfstfarscript_la_LIBADD) $(LIBS) +install-binPROGRAMS: $(bin_PROGRAMS) + @$(NORMAL_INSTALL) + @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \ + if test -n "$$list"; then \ + echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \ + fi; \ + for p in $$list; do echo "$$p $$p"; done | \ + sed 's/$(EXEEXT)$$//' | \ + while read p p1; do if test -f $$p \ + || test -f $$p1 \ + ; then echo "$$p"; echo "$$p"; else :; fi; \ + done | \ + sed -e 'p;s,.*/,,;n;h' \ + -e 's|.*|.|' \ + -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \ + sed 'N;N;N;s,\n, ,g' | \ + $(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \ + { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \ + if ($$2 == $$4) files[d] = files[d] " " $$1; \ + else { print "f", $$3 "/" $$4, $$1; } } \ + END { for (d in files) print "f", d, files[d] }' | \ + while read type dir files; do \ + if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \ + test -z "$$files" || { \ + echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \ + $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \ + } \ + ; done + +uninstall-binPROGRAMS: + @$(NORMAL_UNINSTALL) + @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \ + files=`for p in $$list; do echo "$$p"; done | \ + sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \ + -e 's/$$/$(EXEEXT)/' \ + `; \ + test -n "$$list" || exit 0; \ + echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(bindir)" && rm -f $$files + +clean-binPROGRAMS: + @list='$(bin_PROGRAMS)'; test -n "$$list" || exit 0; \ + echo " rm -f" $$list; \ + rm -f $$list || exit $$?; \ + test -n "$(EXEEXT)" || exit 0; \ + list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \ + echo " rm -f" $$list; \ + rm -f $$list + +farcompilestrings$(EXEEXT): $(farcompilestrings_OBJECTS) $(farcompilestrings_DEPENDENCIES) $(EXTRA_farcompilestrings_DEPENDENCIES) + @rm -f farcompilestrings$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(farcompilestrings_OBJECTS) $(farcompilestrings_LDADD) $(LIBS) + +farcreate$(EXEEXT): $(farcreate_OBJECTS) $(farcreate_DEPENDENCIES) $(EXTRA_farcreate_DEPENDENCIES) + @rm -f farcreate$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(farcreate_OBJECTS) $(farcreate_LDADD) $(LIBS) + +farequal$(EXEEXT): $(farequal_OBJECTS) $(farequal_DEPENDENCIES) $(EXTRA_farequal_DEPENDENCIES) + @rm -f farequal$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(farequal_OBJECTS) $(farequal_LDADD) $(LIBS) + +farextract$(EXEEXT): $(farextract_OBJECTS) $(farextract_DEPENDENCIES) $(EXTRA_farextract_DEPENDENCIES) + @rm -f farextract$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(farextract_OBJECTS) $(farextract_LDADD) $(LIBS) + +farinfo$(EXEEXT): $(farinfo_OBJECTS) $(farinfo_DEPENDENCIES) $(EXTRA_farinfo_DEPENDENCIES) + @rm -f farinfo$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(farinfo_OBJECTS) $(farinfo_LDADD) $(LIBS) + +farisomorphic$(EXEEXT): $(farisomorphic_OBJECTS) $(farisomorphic_DEPENDENCIES) $(EXTRA_farisomorphic_DEPENDENCIES) + @rm -f farisomorphic$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(farisomorphic_OBJECTS) $(farisomorphic_LDADD) $(LIBS) + +farprintstrings$(EXEEXT): $(farprintstrings_OBJECTS) $(farprintstrings_DEPENDENCIES) $(EXTRA_farprintstrings_DEPENDENCIES) + @rm -f farprintstrings$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(farprintstrings_OBJECTS) $(farprintstrings_LDADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/far-class.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farcompilestrings.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farcreate.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farequal.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farextract.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farinfo.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farisomorphic.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farprintstrings.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farscript.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/getters.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/script-impl.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/stlist.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/strings.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sttable.Plo@am__quote@ + +.cc.o: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $< + +.cc.obj: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cc.lo: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ +@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $< + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-am +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-am + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscopelist: cscopelist-am + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(LTLIBRARIES) $(PROGRAMS) +install-binPROGRAMS: install-libLTLIBRARIES + +installdirs: + for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(bindir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \ + clean-libtool mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: install-binPROGRAMS install-libLTLIBRARIES + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-binPROGRAMS uninstall-libLTLIBRARIES + +.MAKE: install-am install-strip + +.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \ + clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \ + clean-libtool cscopelist-am ctags ctags-am distclean \ + distclean-compile distclean-generic distclean-libtool \ + distclean-tags distdir dvi dvi-am html html-am info info-am \ + install install-am install-binPROGRAMS install-data \ + install-data-am install-dvi install-dvi-am install-exec \ + install-exec-am install-html install-html-am install-info \ + install-info-am install-libLTLIBRARIES install-man install-pdf \ + install-pdf-am install-ps install-ps-am install-strip \ + installcheck installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-compile \ + mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ + tags tags-am uninstall uninstall-am uninstall-binPROGRAMS \ + uninstall-libLTLIBRARIES + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/far-class.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/far-class.cc new file mode 100644 index 0000000000..768152b514 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/far-class.cc @@ -0,0 +1,78 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +#include +#include + +namespace fst { +namespace script { + + +// FarReaderClass. + +FarReaderClass *FarReaderClass::Open(const string &filename) { + OpenFarReaderClassArgs1 args(filename); + args.retval = nullptr; + Apply>("OpenFarReaderClass", + LoadArcTypeFromFar(filename), + &args); + return args.retval; +} + +FarReaderClass *FarReaderClass::Open(const std::vector &filenames) { + if (filenames.empty()) { + LOG(ERROR) << "FarReaderClass::Open: No files specified"; + return nullptr; + } + auto it = filenames.cbegin(); + const auto arc_type = LoadArcTypeFromFar(*it); + if (arc_type.empty()) return nullptr; + // FIXME(kbg): Is any of this really necessary? I am doing this purely + // to conform to what I did with fst::script::Replace. + ++it; + for (; it != filenames.cend(); ++it) { + const string other_arc_type = LoadArcTypeFromFar(*it); + if (other_arc_type.empty()) return nullptr; + if (arc_type != other_arc_type) { + LOG(ERROR) << "FarReaderClass::Open: Trying to open FARs with " + << "non-matching arc types:\n\t" << arc_type << " and " + << other_arc_type; + return nullptr; + } + } + OpenFarReaderClassArgs2 args(filenames); + args.retval = nullptr; + Apply>("OpenFarReaderClass", arc_type, + &args); + return args.retval; +} + +REGISTER_FST_OPERATION(OpenFarReaderClass, StdArc, OpenFarReaderClassArgs1); +REGISTER_FST_OPERATION(OpenFarReaderClass, LogArc, OpenFarReaderClassArgs1); +REGISTER_FST_OPERATION(OpenFarReaderClass, Log64Arc, OpenFarReaderClassArgs1); + +REGISTER_FST_OPERATION(OpenFarReaderClass, StdArc, OpenFarReaderClassArgs2); +REGISTER_FST_OPERATION(OpenFarReaderClass, LogArc, OpenFarReaderClassArgs2); +REGISTER_FST_OPERATION(OpenFarReaderClass, Log64Arc, OpenFarReaderClassArgs2); + +// FarWriterClass. + +FarWriterClass *FarWriterClass::Create(const string &filename, + const string &arc_type, FarType type) { + CreateFarWriterClassInnerArgs iargs(filename, type); + CreateFarWriterClassArgs args(iargs); + args.retval = nullptr; + Apply>("CreateFarWriterClass", arc_type, + &args); + return args.retval; +} + +REGISTER_FST_OPERATION(CreateFarWriterClass, StdArc, CreateFarWriterClassArgs); +REGISTER_FST_OPERATION(CreateFarWriterClass, LogArc, CreateFarWriterClassArgs); +REGISTER_FST_OPERATION(CreateFarWriterClass, Log64Arc, + CreateFarWriterClassArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farcompilestrings.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farcompilestrings.cc new file mode 100644 index 0000000000..d510f178e1 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farcompilestrings.cc @@ -0,0 +1,91 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Compiles a set of stings as FSTs and stores them in a finite-state archive. + +#include +#include + +#include +#include +#include +#include + +DEFINE_string(key_prefix, "", "Prefix to append to keys"); +DEFINE_string(key_suffix, "", "Suffix to append to keys"); +DEFINE_int32(generate_keys, 0, + "Generate N digit numeric keys (def: use file basenames)"); +DEFINE_string(far_type, "default", + "FAR file format type: one of: \"default\", \"fst\", " + "\"stlist\", \"sttable\""); +DEFINE_bool(allow_negative_labels, false, + "Allow negative labels (not recommended; may cause conflicts)"); +DEFINE_string(arc_type, "standard", "Output arc type"); +DEFINE_string(entry_type, "line", + "Entry type: one of : " + "\"file\" (one FST per file), \"line\" (one FST per line)"); +DEFINE_string(fst_type, "vector", "Output FST type"); +DEFINE_string(token_type, "symbol", + "Token type: one of : " + "\"symbol\", \"byte\", \"utf8\""); +DEFINE_string(symbols, "", "Label symbol table"); +DEFINE_string(unknown_symbol, "", ""); +DEFINE_bool(file_list_input, false, + "Each input file contains a list of files to be processed"); +DEFINE_bool(keep_symbols, false, "Store symbol table in the FAR file"); +DEFINE_bool(initial_symbols, true, + "When keep_symbols is true, stores symbol table only for the first" + " FST in archive."); + +int main(int argc, char **argv) { + namespace s = fst::script; + + string usage = "Compiles a set of strings as FSTs and stores them in"; + usage += " a finite-state archive.\n\n Usage:"; + usage += argv[0]; + usage += " [in1.txt [[in2.txt ...] out.far]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + s::ExpandArgs(argc, argv, &argc, &argv); + + std::vector in_fnames; + if (FLAGS_file_list_input) { + for (int i = 1; i < argc - 1; ++i) { + std::ifstream istrm(argv[i]); + string str; + while (getline(istrm, str)) in_fnames.push_back(str); + } + } else { + for (int i = 1; i < argc - 1; ++i) + in_fnames.push_back(argv[i]); + } + if (in_fnames.empty()) { + in_fnames.push_back(argc == 2 && strcmp(argv[1], "-") != 0 ? argv[1] : ""); + } + + string out_fname = + argc > 2 && strcmp(argv[argc - 1], "-") != 0 ? argv[argc - 1] : ""; + + fst::FarEntryType entry_type; + if (!s::GetFarEntryType(FLAGS_entry_type, &entry_type)) { + LOG(ERROR) << "Unknown or unsupported FAR entry type: " << FLAGS_entry_type; + return 1; + } + + fst::FarTokenType token_type; + if (!s::GetFarTokenType(FLAGS_token_type, &token_type)) { + LOG(ERROR) << "Unkonwn or unsupported FAR token type: " << FLAGS_token_type; + return 1; + } + + const auto far_type = s::GetFarType(FLAGS_far_type); + + s::FarCompileStrings(in_fnames, out_fname, FLAGS_arc_type, FLAGS_fst_type, + far_type, FLAGS_generate_keys, entry_type, token_type, + FLAGS_symbols, FLAGS_unknown_symbol, FLAGS_keep_symbols, + FLAGS_initial_symbols, FLAGS_allow_negative_labels, + FLAGS_key_prefix, FLAGS_key_suffix); + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farcreate.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farcreate.cc new file mode 100644 index 0000000000..1f26c644cb --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farcreate.cc @@ -0,0 +1,61 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Creates a finite-state archive from input FSTs. + +#include +#include + +#include +#include +#include +#include + +DEFINE_string(key_prefix, "", "Prefix to append to keys"); +DEFINE_string(key_suffix, "", "Suffix to append to keys"); +DEFINE_int32(generate_keys, 0, + "Generate N digit numeric keys (def: use file basenames)"); +DEFINE_string(far_type, "default", + "FAR file format type: one of: \"default\", " + "\"stlist\", \"sttable\""); +DEFINE_bool(file_list_input, false, + "Each input file contains a list of files to be processed"); + +int main(int argc, char **argv) { + namespace s = fst::script; + + string usage = "Creates a finite-state archive from input FSTs.\n\n Usage:"; + usage += argv[0]; + usage += " [in1.fst [[in2.fst ...] out.far]]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + s::ExpandArgs(argc, argv, &argc, &argv); + + std::vector in_fnames; + if (FLAGS_file_list_input) { + for (int i = 1; i < argc - 1; ++i) { + std::ifstream istrm(argv[i]); + string str; + while (getline(istrm, str)) in_fnames.push_back(str); + } + } else { + for (int i = 1; i < argc - 1; ++i) + in_fnames.push_back(argv[i]); + } + if (in_fnames.empty()) + in_fnames.push_back(argc == 2 && strcmp(argv[1], "-") != 0 ? argv[1] : ""); + + string out_fname = + argc > 2 && strcmp(argv[argc - 1], "-") != 0 ? argv[argc - 1] : ""; + + const auto arc_type = s::LoadArcTypeFromFst(in_fnames[0]); + if (arc_type.empty()) return 1; + + const auto far_type = s::GetFarType(FLAGS_far_type); + + s::FarCreate(in_fnames, out_fname, arc_type, FLAGS_generate_keys, far_type, + FLAGS_key_prefix, FLAGS_key_suffix); + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farequal.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farequal.cc new file mode 100644 index 0000000000..8b98faaba3 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farequal.cc @@ -0,0 +1,42 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Tests if two Far files contains the same (key,fst) pairs. + +#include + +#include +#include +#include + +DEFINE_string(begin_key, "", + "First key to extract (def: first key in archive)"); +DEFINE_string(end_key, "", "Last key to extract (def: last key in archive)"); +DEFINE_double(delta, fst::kDelta, "Comparison/quantization delta"); + +int main(int argc, char **argv) { + namespace s = fst::script; + + string usage = "Compares the FSTs in two FST archives for equality."; + usage += "\n\n Usage:"; + usage += argv[0]; + usage += " in1.far in2.far"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + s::ExpandArgs(argc, argv, &argc, &argv); + if (argc != 3) { + ShowUsage(); + return 1; + } + + const auto arc_type = s::LoadArcTypeFromFar(argv[1]); + if (arc_type.empty()) return 1; + + bool result = s::FarEqual(argv[1], argv[2], arc_type, FLAGS_delta, + FLAGS_begin_key, FLAGS_end_key); + + if (!result) VLOG(1) << "FARs are not equal."; + + return result ? 0 : 2; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farextract.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farextract.cc new file mode 100644 index 0000000000..df40bd4b76 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farextract.cc @@ -0,0 +1,46 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Extracts component FSTs from an finite-state archive. + +#include +#include + +#include +#include +#include + +DEFINE_string(filename_prefix, "", "Prefix to append to filenames"); +DEFINE_string(filename_suffix, "", "Suffix to append to filenames"); +DEFINE_int32(generate_filenames, 0, + "Generate N digit numeric filenames (def: use keys)"); +DEFINE_string(keys, "", + "Extract set of keys separated by comma (default) " + "including ranges delimited by dash (default)"); +DEFINE_string(key_separator, ",", "Separator for individual keys"); +DEFINE_string(range_delimiter, "-", "Delimiter for ranges of keys"); + +int main(int argc, char **argv) { + namespace s = fst::script; + + string usage = "Extracts FSTs from a finite-state archive.\n\n Usage:"; + usage += argv[0]; + usage += " [in1.far in2.far...]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + s::ExpandArgs(argc, argv, &argc, &argv); + + std::vector in_fnames; + for (int i = 1; i < argc; ++i) in_fnames.push_back(argv[i]); + if (in_fnames.empty()) in_fnames.push_back(""); + + const auto arc_type = s::LoadArcTypeFromFar(in_fnames[0]); + if (arc_type.empty()) return 1; + + s::FarExtract(in_fnames, arc_type, FLAGS_generate_filenames, FLAGS_keys, + FLAGS_key_separator, FLAGS_range_delimiter, + FLAGS_filename_prefix, FLAGS_filename_suffix); + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farinfo.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farinfo.cc new file mode 100644 index 0000000000..f004d3e51f --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farinfo.cc @@ -0,0 +1,44 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Prints some basic information about the FSTs in an FST archive. + +#include +#include + +#include +#include +#include + +DEFINE_string(begin_key, "", + "First key to extract (default: first key in archive)"); +DEFINE_string(end_key, "", + "Last key to extract (default: last key in archive)"); + +DEFINE_bool(list_fsts, false, "Display FST information for each key"); + +int main(int argc, char **argv) { + namespace s = fst::script; + + string usage = "Prints some basic information about the FSTs in an FST "; + usage += "archive.\n\n Usage:"; + usage += argv[0]; + usage += " [in1.far in2.far...]\n"; + usage += " Flags: begin_key end_key list_fsts"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + s::ExpandArgs(argc, argv, &argc, &argv); + + std::vector in_fnames; + for (int i = 1; i < argc; ++i) in_fnames.push_back(argv[i]); + if (in_fnames.empty()) in_fnames.push_back(""); + + const auto arc_type = s::LoadArcTypeFromFar(in_fnames[0]); + if (arc_type.empty()) return 1; + + s::FarInfo(in_fnames, arc_type, FLAGS_begin_key, FLAGS_end_key, + FLAGS_list_fsts); + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farisomorphic.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farisomorphic.cc new file mode 100644 index 0000000000..6efda1d534 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farisomorphic.cc @@ -0,0 +1,44 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Tests if two Far files contains isomorphic (key,fst) pairs. + +#include + +#include +#include +#include + +DEFINE_string(begin_key, "", + "First key to extract (def: first key in archive)"); +DEFINE_string(end_key, "", "Last key to extract (def: last key in archive)"); +DEFINE_double(delta, fst::kDelta, "Comparison/quantization delta"); + +int main(int argc, char **argv) { + namespace s = fst::script; + + string usage = "Compares the FSTs in two FST archives for isomorphism."; + usage += "\n\n Usage:"; + usage += argv[0]; + usage += " in1.far in2.far\n"; + usage += " Flags: begin_key end_key"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + s::ExpandArgs(argc, argv, &argc, &argv); + + if (argc != 3) { + ShowUsage(); + return 1; + } + + const auto arc_type = s::LoadArcTypeFromFar(argv[1]); + if (arc_type.empty()) return 1; + + bool result = s::FarIsomorphic(argv[1], argv[2], arc_type, + FLAGS_delta, FLAGS_begin_key, FLAGS_end_key); + + if (!result) VLOG(1) << "FARs are not isomorphic."; + + return result ? 0 : 2; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farprintstrings.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farprintstrings.cc new file mode 100644 index 0000000000..bcd5d452f2 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farprintstrings.cc @@ -0,0 +1,70 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Outputs as strings the string FSTs in a finite-state archive. + +#include +#include + +#include +#include +#include + +DEFINE_string(filename_prefix, "", "Prefix to append to filenames"); +DEFINE_string(filename_suffix, "", "Suffix to append to filenames"); +DEFINE_int32(generate_filenames, 0, + "Generate N digit numeric filenames (def: use keys)"); +DEFINE_string(begin_key, "", + "First key to extract (def: first key in archive)"); +DEFINE_string(end_key, "", "Last key to extract (def: last key in archive)"); +// PrintStringsMain specific flag definitions. +DEFINE_bool(print_key, false, "Prefix each string by its key"); +DEFINE_bool(print_weight, false, "Suffix each string by its weight"); +DEFINE_string(entry_type, "line", + "Entry type: one of : " + "\"file\" (one FST per file), \"line\" (one FST per line)"); +DEFINE_string(token_type, "symbol", + "Token type: one of : " + "\"symbol\", \"byte\", \"utf8\""); +DEFINE_string(symbols, "", "Label symbol table"); +DEFINE_bool(initial_symbols, true, + "Uses symbol table from the first Fst in archive for all entries."); + +int main(int argc, char **argv) { + namespace s = fst::script; + + string usage = "Print as string the string FSTs in an archive.\n\n Usage:"; + usage += argv[0]; + usage += " [in1.far in2.far ...]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + s::ExpandArgs(argc, argv, &argc, &argv); + + std::vector in_fnames; + for (int i = 1; i < argc; ++i) in_fnames.push_back(argv[i]); + if (in_fnames.empty()) in_fnames.push_back(""); + + const auto arc_type = s::LoadArcTypeFromFar(in_fnames[0]); + if (arc_type.empty()) return 1; + + fst::FarEntryType entry_type; + if (!s::GetFarEntryType(FLAGS_entry_type, &entry_type)) { + LOG(ERROR) << "Unknown or unsupported FAR entry type: " << FLAGS_entry_type; + return 1; + } + + fst::FarTokenType token_type; + if (!s::GetFarTokenType(FLAGS_token_type, &token_type)) { + LOG(ERROR) << "Unknown or unsupported FAR token type: " << FLAGS_token_type; + return 1; + } + + s::FarPrintStrings(in_fnames, arc_type, entry_type, token_type, + FLAGS_begin_key, FLAGS_end_key, FLAGS_print_key, + FLAGS_print_weight, FLAGS_symbols, FLAGS_initial_symbols, + FLAGS_generate_filenames, FLAGS_filename_prefix, + FLAGS_filename_suffix); + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farscript.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farscript.cc new file mode 100644 index 0000000000..17c6c467cd --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/farscript.cc @@ -0,0 +1,102 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Definitions of 'scriptable' versions of FAR operations, that is, +// those that can be called with FstClass-type arguments. + +#include +#include +#include + +namespace fst { +namespace script { + +void FarCompileStrings(const std::vector &in_fnames, + const string &out_fname, const string &arc_type, + const string &fst_type, const FarType &far_type, + int32 generate_keys, FarEntryType fet, FarTokenType tt, + const string &symbols_fname, + const string &unknown_symbol, bool keep_symbols, + bool initial_symbols, bool allow_negative_labels, + const string &key_prefix, const string &key_suffix) { + FarCompileStringsArgs args(in_fnames, out_fname, fst_type, far_type, + generate_keys, fet, tt, symbols_fname, + unknown_symbol, keep_symbols, initial_symbols, + allow_negative_labels, key_prefix, key_suffix); + Apply>("FarCompileStrings", arc_type, &args); +} + +void FarCreate(const std::vector &in_fnames, const string &out_fname, + const string &arc_type, const int32 generate_keys, + const FarType &far_type, const string &key_prefix, + const string &key_suffix) { + FarCreateArgs args(in_fnames, out_fname, generate_keys, far_type, key_prefix, + key_suffix); + Apply>("FarCreate", arc_type, &args); +} + +bool FarEqual(const string &filename1, const string &filename2, + const string &arc_type, float delta, const string &begin_key, + const string &end_key) { + FarEqualInnerArgs args(filename1, filename2, delta, begin_key, end_key); + FarEqualArgs args_with_retval(args); + Apply>("FarEqual", arc_type, &args_with_retval); + return args_with_retval.retval; +} + +void FarExtract(const std::vector &ifilenames, const string &arc_type, + int32 generate_filenames, const string &keys, + const string &key_separator, const string &range_delimiter, + const string &filename_prefix, const string &filename_suffix) { + FarExtractArgs args(ifilenames, generate_filenames, keys, key_separator, + range_delimiter, filename_prefix, filename_suffix); + Apply>("FarExtract", arc_type, &args); +} + +void FarInfo(const std::vector &filenames, const string &arc_type, + const string &begin_key, const string &end_key, + const bool list_fsts) { + FarInfoArgs args(filenames, begin_key, end_key, list_fsts); + Apply>("FarInfo", arc_type, &args); +} + +void GetFarInfo(const std::vector &filenames, const string &arc_type, + const string &begin_key, const string &end_key, + const bool list_fsts, FarInfoData *data) { + GetFarInfoArgs args(filenames, begin_key, end_key, list_fsts, data); + Apply>("GetFarInfo", arc_type, &args); +} + +bool FarIsomorphic(const string &filename1, const string &filename2, + const string &arc_type, float delta, const string &begin_key, + const string &end_key) { + FarIsomorphicInnerArgs args(filename1, filename2, delta, begin_key, end_key); + FarIsomorphicArgs args_with_retval(args); + Apply>("FarIsomorphic", arc_type, + &args_with_retval); + return args_with_retval.retval; +} + +void FarPrintStrings(const std::vector &ifilenames, + const string &arc_type, const FarEntryType entry_type, + const FarTokenType token_type, const string &begin_key, + const string &end_key, const bool print_key, + const bool print_weight, const string &symbols_fname, + const bool initial_symbols, const int32 generate_filenames, + const string &filename_prefix, + const string &filename_suffix) { + FarPrintStringsArgs args(ifilenames, entry_type, token_type, begin_key, + end_key, print_key, print_weight, symbols_fname, + initial_symbols, generate_filenames, filename_prefix, + filename_suffix); + Apply>("FarPrintStrings", arc_type, &args); +} + +// Instantiate all templates for common arc types. + +REGISTER_FST_FAR_OPERATIONS(StdArc); +REGISTER_FST_FAR_OPERATIONS(LogArc); +REGISTER_FST_FAR_OPERATIONS(Log64Arc); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/getters.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/getters.cc new file mode 100644 index 0000000000..a2ffe5f5b8 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/getters.cc @@ -0,0 +1,75 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// +// Definitions and functions for invoking and using Far main functions that +// support multiple and extensible arc types. + +#include + +#include +#include + +#include + +namespace fst { + +namespace script { + +FarType GetFarType(const string &str) { + if (str == "fst") { + return FAR_FST; + } else if (str == "stlist") { + return FAR_STLIST; + } else if (str == "sttable") { + return FAR_STTABLE; + } else { + return FAR_DEFAULT; + } +} + +bool GetFarEntryType(const string &str, FarEntryType *entry_type) { + if (str == "line") { + *entry_type = FET_LINE; + } else if (str == "file") { + *entry_type = FET_FILE; + } else { + return false; + } + return true; +} + +bool GetFarTokenType(const string &str, FarTokenType *token_type) { + if (str == "symbol") { + *token_type = FTT_SYMBOL; + } else if (str == "byte") { + *token_type = FTT_BYTE; + } else if (str == "utf8") { + *token_type = FTT_UTF8; + } else { + return false; + } + return true; +} + +void ExpandArgs(int argc, char **argv, int *argcp, char ***argvp) { +} + +} // namespace script + +string GetFarTypeString(FarType type) { + switch (type) { + case FAR_FST: + return "fst"; + case FAR_STLIST: + return "stlist"; + case FAR_STTABLE: + return "sttable"; + case FAR_DEFAULT: + return "default"; + default: + return ""; + } +} + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/script-impl.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/script-impl.cc new file mode 100644 index 0000000000..6fd13316b7 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/script-impl.cc @@ -0,0 +1,42 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Definitions and functions for invoking and using Far main functions that +// support multiple and extensible arc types. + +#include + +#include + +#include +#include + +namespace fst { +namespace script { + +string LoadArcTypeFromFar(const string &far_fname) { + FarHeader hdr; + if (!hdr.Read(far_fname)) { + LOG(ERROR) << "Error reading FAR: " << far_fname; + return ""; + } + string atype = hdr.ArcType(); + if (atype == "unknown") { + LOG(ERROR) << "Empty FST archive: " << far_fname; + return ""; + } + return atype; +} + +string LoadArcTypeFromFst(const string &fst_fname) { + FstHeader hdr; + std::ifstream in(fst_fname, std::ios_base::in | std::ios_base::binary); + if (!hdr.Read(in, fst_fname)) { + LOG(ERROR) << "Error reading FST: " << fst_fname; + return ""; + } + return hdr.ArcType(); +} + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/stlist.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/stlist.cc new file mode 100644 index 0000000000..89e4b9023e --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/stlist.cc @@ -0,0 +1,19 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +#include +#include + +namespace fst { + +bool IsSTList(const string &filename) { + std::ifstream strm(filename, std::ios_base::in | std::ios_base::binary); + if (!strm) return false; + int32 magic_number = 0; + ReadType(strm, &magic_number); + return magic_number == kSTListMagicNumber; +} + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/strings.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/strings.cc new file mode 100644 index 0000000000..ad516d1601 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/strings.cc @@ -0,0 +1,28 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +#include +#include +#include + +DEFINE_string(far_field_separator, "\t", + "Set of characters used as a separator between printed fields"); + +namespace fst { + +// Computes the minimal length required to encode each line number as a decimal +// number. +int KeySize(const char *filename) { + std::ifstream istrm(filename); + istrm.seekg(0); + string s; + int nline = 0; + while (getline(istrm, s)) ++nline; + istrm.seekg(0); + return nline ? ceil(log10(nline + 1)) : 1; +} + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/sttable.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/sttable.cc new file mode 100644 index 0000000000..bf7d4a2a21 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/far/sttable.cc @@ -0,0 +1,18 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { + +bool IsSTTable(const string &filename) { + std::ifstream strm(filename); + if (!strm.good()) return false; + + int32 magic_number = 0; + ReadType(strm, &magic_number); + return magic_number == kSTTableMagicNumber; +} + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/linear/Makefile.am b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/linear/Makefile.am new file mode 100644 index 0000000000..48e9ed0689 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/linear/Makefile.am @@ -0,0 +1,35 @@ +AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) + +if HAVE_BIN +bin_PROGRAMS = fstlinear fstloglinearapply + +LDADD = libfstlinearscript.la ../../script/libfstscript.la \ + ../../lib/libfst.la -lm $(DL_LIBS) + +fstlinear_SOURCES = fstlinear.cc + +fstloglinearapply_SOURCES = fstloglinearapply.cc +endif + +if HAVE_SCRIPT +libfstlinearscript_la_SOURCES = linearscript.cc +libfstlinearscript_la_LDFLAGS = -version-info 10:0:0 -lm $(DL_LIBS) +libfstlinearscript_la_LIBADD = ../../script/libfstscript.la \ + ../../lib/libfst.la -lm $(DL_LIBS) +endif + +if HAVE_SCRIPT +libfst_LTLIBRARIES = linear_tagger-fst.la \ + linear_classifier-fst.la +lib_LTLIBRARIES = libfstlinearscript.la +else +libfst_LTLIBRARIES = linear_tagger-fst.la linear_classifier-fst.la +endif + +libfstdir = @libfstdir@ + +linear_tagger_fst_la_SOURCES = linear-tagger-fst.cc +linear_tagger_fst_la_LDFLAGS = -module + +linear_classifier_fst_la_SOURCES = linear-classifier-fst.cc +linear_classifier_fst_la_LDFLAGS = -module diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/linear/Makefile.in b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/linear/Makefile.in new file mode 100644 index 0000000000..293b889b42 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/linear/Makefile.in @@ -0,0 +1,832 @@ +# Makefile.in generated by automake 1.14.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2013 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + + +VPATH = @srcdir@ +am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +@HAVE_BIN_TRUE@bin_PROGRAMS = fstlinear$(EXEEXT) \ +@HAVE_BIN_TRUE@ fstloglinearapply$(EXEEXT) +subdir = src/extensions/linear +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ + $(top_srcdir)/depcomp +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \ + $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ + $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ + $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h \ + $(top_builddir)/src/include/fst/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__uninstall_files_from_dir = { \ + test -z "$$files" \ + || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && rm -f $$files; }; \ + } +am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)" \ + "$(DESTDIR)$(bindir)" +LTLIBRARIES = $(lib_LTLIBRARIES) $(libfst_LTLIBRARIES) +am__DEPENDENCIES_1 = +@HAVE_SCRIPT_TRUE@libfstlinearscript_la_DEPENDENCIES = \ +@HAVE_SCRIPT_TRUE@ ../../script/libfstscript.la \ +@HAVE_SCRIPT_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +am__libfstlinearscript_la_SOURCES_DIST = linearscript.cc +@HAVE_SCRIPT_TRUE@am_libfstlinearscript_la_OBJECTS = linearscript.lo +libfstlinearscript_la_OBJECTS = $(am_libfstlinearscript_la_OBJECTS) +AM_V_lt = $(am__v_lt_@AM_V@) +am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) +am__v_lt_0 = --silent +am__v_lt_1 = +libfstlinearscript_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) $(libfstlinearscript_la_LDFLAGS) \ + $(LDFLAGS) -o $@ +@HAVE_SCRIPT_TRUE@am_libfstlinearscript_la_rpath = -rpath $(libdir) +linear_classifier_fst_la_LIBADD = +am_linear_classifier_fst_la_OBJECTS = linear-classifier-fst.lo +linear_classifier_fst_la_OBJECTS = \ + $(am_linear_classifier_fst_la_OBJECTS) +linear_classifier_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) $(linear_classifier_fst_la_LDFLAGS) \ + $(LDFLAGS) -o $@ +@HAVE_SCRIPT_FALSE@am_linear_classifier_fst_la_rpath = -rpath \ +@HAVE_SCRIPT_FALSE@ $(libfstdir) +@HAVE_SCRIPT_TRUE@am_linear_classifier_fst_la_rpath = -rpath \ +@HAVE_SCRIPT_TRUE@ $(libfstdir) +linear_tagger_fst_la_LIBADD = +am_linear_tagger_fst_la_OBJECTS = linear-tagger-fst.lo +linear_tagger_fst_la_OBJECTS = $(am_linear_tagger_fst_la_OBJECTS) +linear_tagger_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) $(linear_tagger_fst_la_LDFLAGS) \ + $(LDFLAGS) -o $@ +@HAVE_SCRIPT_FALSE@am_linear_tagger_fst_la_rpath = -rpath $(libfstdir) +@HAVE_SCRIPT_TRUE@am_linear_tagger_fst_la_rpath = -rpath $(libfstdir) +PROGRAMS = $(bin_PROGRAMS) +am__fstlinear_SOURCES_DIST = fstlinear.cc +@HAVE_BIN_TRUE@am_fstlinear_OBJECTS = fstlinear.$(OBJEXT) +fstlinear_OBJECTS = $(am_fstlinear_OBJECTS) +fstlinear_LDADD = $(LDADD) +@HAVE_BIN_TRUE@fstlinear_DEPENDENCIES = libfstlinearscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +am__fstloglinearapply_SOURCES_DIST = fstloglinearapply.cc +@HAVE_BIN_TRUE@am_fstloglinearapply_OBJECTS = \ +@HAVE_BIN_TRUE@ fstloglinearapply.$(OBJEXT) +fstloglinearapply_OBJECTS = $(am_fstloglinearapply_OBJECTS) +fstloglinearapply_LDADD = $(LDADD) +@HAVE_BIN_TRUE@fstloglinearapply_DEPENDENCIES = libfstlinearscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +DEFAULT_INCLUDES = +depcomp = $(SHELL) $(top_srcdir)/depcomp +am__depfiles_maybe = depfiles +am__mv = mv -f +CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CXXFLAGS) $(CXXFLAGS) +AM_V_CXX = $(am__v_CXX_@AM_V@) +am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@) +am__v_CXX_0 = @echo " CXX " $@; +am__v_CXX_1 = +CXXLD = $(CXX) +CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_CXXLD = $(am__v_CXXLD_@AM_V@) +am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@) +am__v_CXXLD_0 = @echo " CXXLD " $@; +am__v_CXXLD_1 = +SOURCES = $(libfstlinearscript_la_SOURCES) \ + $(linear_classifier_fst_la_SOURCES) \ + $(linear_tagger_fst_la_SOURCES) $(fstlinear_SOURCES) \ + $(fstloglinearapply_SOURCES) +DIST_SOURCES = $(am__libfstlinearscript_la_SOURCES_DIST) \ + $(linear_classifier_fst_la_SOURCES) \ + $(linear_tagger_fst_la_SOURCES) $(am__fstlinear_SOURCES_DIST) \ + $(am__fstloglinearapply_SOURCES_DIST) +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DL_LIBS = @DL_LIBS@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PYTHON = @PYTHON@ +PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@ +PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ +PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@ +PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@ +PYTHON_LDFLAGS = @PYTHON_LDFLAGS@ +PYTHON_PLATFORM = @PYTHON_PLATFORM@ +PYTHON_PREFIX = @PYTHON_PREFIX@ +PYTHON_SITE_PKG = @PYTHON_SITE_PKG@ +PYTHON_VERSION = @PYTHON_VERSION@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +libfstdir = @libfstdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgpyexecdir = @pkgpyexecdir@ +pkgpythondir = @pkgpythondir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +pyexecdir = @pyexecdir@ +pythondir = @pythondir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) +@HAVE_BIN_TRUE@LDADD = libfstlinearscript.la ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la -lm $(DL_LIBS) + +@HAVE_BIN_TRUE@fstlinear_SOURCES = fstlinear.cc +@HAVE_BIN_TRUE@fstloglinearapply_SOURCES = fstloglinearapply.cc +@HAVE_SCRIPT_TRUE@libfstlinearscript_la_SOURCES = linearscript.cc +@HAVE_SCRIPT_TRUE@libfstlinearscript_la_LDFLAGS = -version-info 10:0:0 -lm $(DL_LIBS) +@HAVE_SCRIPT_TRUE@libfstlinearscript_la_LIBADD = ../../script/libfstscript.la \ +@HAVE_SCRIPT_TRUE@ ../../lib/libfst.la -lm $(DL_LIBS) + +@HAVE_SCRIPT_FALSE@libfst_LTLIBRARIES = linear_tagger-fst.la linear_classifier-fst.la +@HAVE_SCRIPT_TRUE@libfst_LTLIBRARIES = linear_tagger-fst.la \ +@HAVE_SCRIPT_TRUE@ linear_classifier-fst.la + +@HAVE_SCRIPT_TRUE@lib_LTLIBRARIES = libfstlinearscript.la +linear_tagger_fst_la_SOURCES = linear-tagger-fst.cc +linear_tagger_fst_la_LDFLAGS = -module +linear_classifier_fst_la_SOURCES = linear-classifier-fst.cc +linear_classifier_fst_la_LDFLAGS = -module +all: all-am + +.SUFFIXES: +.SUFFIXES: .cc .lo .o .obj +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/linear/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign src/extensions/linear/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +install-libLTLIBRARIES: $(lib_LTLIBRARIES) + @$(NORMAL_INSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \ + } + +uninstall-libLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \ + done + +clean-libLTLIBRARIES: + -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES) + @list='$(lib_LTLIBRARIES)'; \ + locs=`for p in $$list; do echo $$p; done | \ + sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ + sort -u`; \ + test -z "$$locs" || { \ + echo rm -f $${locs}; \ + rm -f $${locs}; \ + } + +install-libfstLTLIBRARIES: $(libfst_LTLIBRARIES) + @$(NORMAL_INSTALL) + @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(libfstdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(libfstdir)" || exit 1; \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libfstdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libfstdir)"; \ + } + +uninstall-libfstLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libfstdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libfstdir)/$$f"; \ + done + +clean-libfstLTLIBRARIES: + -test -z "$(libfst_LTLIBRARIES)" || rm -f $(libfst_LTLIBRARIES) + @list='$(libfst_LTLIBRARIES)'; \ + locs=`for p in $$list; do echo $$p; done | \ + sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ + sort -u`; \ + test -z "$$locs" || { \ + echo rm -f $${locs}; \ + rm -f $${locs}; \ + } + +libfstlinearscript.la: $(libfstlinearscript_la_OBJECTS) $(libfstlinearscript_la_DEPENDENCIES) $(EXTRA_libfstlinearscript_la_DEPENDENCIES) + $(AM_V_CXXLD)$(libfstlinearscript_la_LINK) $(am_libfstlinearscript_la_rpath) $(libfstlinearscript_la_OBJECTS) $(libfstlinearscript_la_LIBADD) $(LIBS) + +linear_classifier-fst.la: $(linear_classifier_fst_la_OBJECTS) $(linear_classifier_fst_la_DEPENDENCIES) $(EXTRA_linear_classifier_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(linear_classifier_fst_la_LINK) $(am_linear_classifier_fst_la_rpath) $(linear_classifier_fst_la_OBJECTS) $(linear_classifier_fst_la_LIBADD) $(LIBS) + +linear_tagger-fst.la: $(linear_tagger_fst_la_OBJECTS) $(linear_tagger_fst_la_DEPENDENCIES) $(EXTRA_linear_tagger_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(linear_tagger_fst_la_LINK) $(am_linear_tagger_fst_la_rpath) $(linear_tagger_fst_la_OBJECTS) $(linear_tagger_fst_la_LIBADD) $(LIBS) +install-binPROGRAMS: $(bin_PROGRAMS) + @$(NORMAL_INSTALL) + @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \ + if test -n "$$list"; then \ + echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \ + fi; \ + for p in $$list; do echo "$$p $$p"; done | \ + sed 's/$(EXEEXT)$$//' | \ + while read p p1; do if test -f $$p \ + || test -f $$p1 \ + ; then echo "$$p"; echo "$$p"; else :; fi; \ + done | \ + sed -e 'p;s,.*/,,;n;h' \ + -e 's|.*|.|' \ + -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \ + sed 'N;N;N;s,\n, ,g' | \ + $(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \ + { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \ + if ($$2 == $$4) files[d] = files[d] " " $$1; \ + else { print "f", $$3 "/" $$4, $$1; } } \ + END { for (d in files) print "f", d, files[d] }' | \ + while read type dir files; do \ + if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \ + test -z "$$files" || { \ + echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \ + $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \ + } \ + ; done + +uninstall-binPROGRAMS: + @$(NORMAL_UNINSTALL) + @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \ + files=`for p in $$list; do echo "$$p"; done | \ + sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \ + -e 's/$$/$(EXEEXT)/' \ + `; \ + test -n "$$list" || exit 0; \ + echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(bindir)" && rm -f $$files + +clean-binPROGRAMS: + @list='$(bin_PROGRAMS)'; test -n "$$list" || exit 0; \ + echo " rm -f" $$list; \ + rm -f $$list || exit $$?; \ + test -n "$(EXEEXT)" || exit 0; \ + list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \ + echo " rm -f" $$list; \ + rm -f $$list + +fstlinear$(EXEEXT): $(fstlinear_OBJECTS) $(fstlinear_DEPENDENCIES) $(EXTRA_fstlinear_DEPENDENCIES) + @rm -f fstlinear$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstlinear_OBJECTS) $(fstlinear_LDADD) $(LIBS) + +fstloglinearapply$(EXEEXT): $(fstloglinearapply_OBJECTS) $(fstloglinearapply_DEPENDENCIES) $(EXTRA_fstloglinearapply_DEPENDENCIES) + @rm -f fstloglinearapply$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstloglinearapply_OBJECTS) $(fstloglinearapply_LDADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstlinear.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstloglinearapply.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/linear-classifier-fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/linear-tagger-fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/linearscript.Plo@am__quote@ + +.cc.o: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $< + +.cc.obj: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cc.lo: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ +@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $< + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-am +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-am + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscopelist: cscopelist-am + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(LTLIBRARIES) $(PROGRAMS) +install-binPROGRAMS: install-libLTLIBRARIES + +installdirs: + for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)" "$(DESTDIR)$(bindir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \ + clean-libfstLTLIBRARIES clean-libtool mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: install-libfstLTLIBRARIES + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: install-binPROGRAMS install-libLTLIBRARIES + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-binPROGRAMS uninstall-libLTLIBRARIES \ + uninstall-libfstLTLIBRARIES + +.MAKE: install-am install-strip + +.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \ + clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \ + clean-libfstLTLIBRARIES clean-libtool cscopelist-am ctags \ + ctags-am distclean distclean-compile distclean-generic \ + distclean-libtool distclean-tags distdir dvi dvi-am html \ + html-am info info-am install install-am install-binPROGRAMS \ + install-data install-data-am install-dvi install-dvi-am \ + install-exec install-exec-am install-html install-html-am \ + install-info install-info-am install-libLTLIBRARIES \ + install-libfstLTLIBRARIES install-man install-pdf \ + install-pdf-am install-ps install-ps-am install-strip \ + installcheck installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-compile \ + mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ + tags tags-am uninstall uninstall-am uninstall-binPROGRAMS \ + uninstall-libLTLIBRARIES uninstall-libfstLTLIBRARIES + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/linear/fstlinear.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/linear/fstlinear.cc new file mode 100644 index 0000000000..502a385a09 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/linear/fstlinear.cc @@ -0,0 +1,36 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +#include + +DEFINE_string(arc_type, "standard", "Output arc type"); + +DEFINE_string(epsilon_symbol, "", "Epsilon symbol"); +DEFINE_string(unknown_symbol, "", "Unknown word symbol"); + +DEFINE_string(vocab, "", "Path to the vocabulary file"); +DEFINE_string(out, "", "Path to the output binary"); + +DEFINE_string(save_isymbols, "", "Save input symbol table to file"); +DEFINE_string(save_fsymbols, "", "Save feature symbol table to file"); +DEFINE_string(save_osymbols, "", "Save output symbol table to file"); + +int main(int argc, char **argv) { + // TODO(wuke): more detailed usage + std::set_new_handler(FailedNewHandler); + SET_FLAGS(argv[0], &argc, &argv, true); + fst::script::ValidateDelimiter(); + fst::script::ValidateEmptySymbol(); + + if (argc == 1) { + ShowUsage(); + return 1; + } + + fst::script::LinearCompile(FLAGS_arc_type, FLAGS_epsilon_symbol, + FLAGS_unknown_symbol, FLAGS_vocab, argv + 1, + argc - 1, FLAGS_out, FLAGS_save_isymbols, + FLAGS_save_fsymbols, FLAGS_save_osymbols); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/linear/fstloglinearapply.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/linear/fstloglinearapply.cc new file mode 100644 index 0000000000..69e269dc6e --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/linear/fstloglinearapply.cc @@ -0,0 +1,51 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include +#include + +#include +#include + +DEFINE_bool(normalize, true, "Normalize to get posterior"); + +int main(int argc, char **argv) { + string usage = + "Applies an FST to another FST, treating the second as a log-linear " + "model.\n\n " + "Usage: "; + usage += argv[0]; + usage += " in.fst linear.fst [out.fst]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc < 3 || argc > 4) { + ShowUsage(); + return 1; + } + + string in_name = strcmp(argv[1], "-") != 0 ? argv[1] : ""; + string linear_name = (argc > 2 && (strcmp(argv[2], "-") != 0)) ? argv[2] : ""; + string out_name = argc > 3 ? argv[3] : ""; + + if (in_name.empty() && linear_name.empty()) { + LOG(ERROR) << argv[0] << ": Can't take both inputs from standard input."; + return 1; + } + + fst::StdFst *ifst1 = fst::StdFst::Read(in_name); + if (!ifst1) return 1; + + fst::StdFst *ifst2 = fst::StdFst::Read(linear_name); + if (!ifst2) return 1; + + fst::StdVectorFst ofst; + + LogLinearApply(*ifst1, *ifst2, &ofst, FLAGS_normalize); + + ofst.Write(out_name); + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/linear/linear-classifier-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/linear/linear-classifier-fst.cc new file mode 100644 index 0000000000..d2e248e825 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/linear/linear-classifier-fst.cc @@ -0,0 +1,12 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +using fst::LinearClassifierFst; +using fst::StdArc; +using fst::LogArc; + +REGISTER_FST(LinearClassifierFst, StdArc); +REGISTER_FST(LinearClassifierFst, LogArc); diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/linear/linear-tagger-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/linear/linear-tagger-fst.cc new file mode 100644 index 0000000000..0110fa7d42 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/linear/linear-tagger-fst.cc @@ -0,0 +1,12 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +using fst::LinearTaggerFst; +using fst::StdArc; +using fst::LogArc; + +REGISTER_FST(LinearTaggerFst, StdArc); +REGISTER_FST(LinearTaggerFst, LogArc); diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/linear/linearscript.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/linear/linearscript.cc new file mode 100644 index 0000000000..be15886438 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/linear/linearscript.cc @@ -0,0 +1,91 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +DEFINE_string(delimiter, "|", + "Single non-white-space character delimiter inside sequences of " + "feature symbols and output symbols"); +DEFINE_string(empty_symbol, "", + "Special symbol that designates an empty sequence"); + +DEFINE_string(start_symbol, "", "Start of sentence symbol"); +DEFINE_string(end_symbol, "", "End of sentence symbol"); + +DEFINE_bool(classifier, false, + "Treat input model as a classifier instead of a tagger"); + +namespace fst { +namespace script { + +bool ValidateDelimiter() { + if (FLAGS_delimiter.size() == 1 && !std::isspace(FLAGS_delimiter[0])) + return true; + return false; +} + +bool ValidateEmptySymbol() { + bool okay = !FLAGS_empty_symbol.empty(); + for (size_t i = 0; i < FLAGS_empty_symbol.size(); ++i) { + char c = FLAGS_empty_symbol[i]; + if (std::isspace(c)) okay = false; + } + return okay; +} + +void LinearCompile(const string &arc_type, const string &epsilon_symbol, + const string &unknown_symbol, const string &vocab, + char **models, int models_len, const string &out, + const string &save_isymbols, const string &save_fsymbols, + const string &save_osymbols) { + LinearCompileArgs args(epsilon_symbol, unknown_symbol, vocab, models, + models_len, out, save_isymbols, save_fsymbols, + save_osymbols); + Apply>("LinearCompileTpl", arc_type, &args); +} + +// Instantiate templates for common arc types +REGISTER_FST_LINEAR_OPERATIONS(StdArc); +REGISTER_FST_LINEAR_OPERATIONS(LogArc); + +void SplitByWhitespace(const string &str, std::vector *out) { + out->clear(); + std::istringstream strm(str); + string buf; + while (strm >> buf) out->push_back(buf); +} + +int ScanNumClasses(char **models, int models_len) { + std::set preds; + for (int i = 0; i < models_len; ++i) { + std::ifstream in(models[i]); + if (!in) LOG(FATAL) << "Failed to open " << models[i]; + + string line; + std::getline(in, line); + + size_t num_line = 1; + while (std::getline(in, line)) { + ++num_line; + std::vector fields; + SplitByWhitespace(line, &fields); + if (fields.size() != 3) + LOG(FATAL) << "Wrong number of fields in source " << models[i] + << ", line " << num_line; + preds.insert(fields[1]); + } + } + return preds.size(); +} + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/lookahead/Makefile.am b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/lookahead/Makefile.am new file mode 100644 index 0000000000..1f502ed47f --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/lookahead/Makefile.am @@ -0,0 +1,21 @@ +AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) + +libfstdir = @libfstdir@ +libfst_LTLIBRARIES = arc_lookahead-fst.la \ +ilabel_lookahead-fst.la olabel_lookahead-fst.la + +lib_LTLIBRARIES = libfstlookahead.la + +libfstlookahead_la_SOURCES = arc_lookahead-fst.cc ilabel_lookahead-fst.cc \ + olabel_lookahead-fst.cc +libfstlookahead_la_LDFLAGS = -version-info 10:0:0 +libfstlookahead_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS) + +arc_lookahead_fst_la_SOURCES = arc_lookahead-fst.cc +arc_lookahead_fst_la_LDFLAGS = -module + +ilabel_lookahead_fst_la_SOURCES = ilabel_lookahead-fst.cc +ilabel_lookahead_fst_la_LDFLAGS = -module + +olabel_lookahead_fst_la_SOURCES = olabel_lookahead-fst.cc +olabel_lookahead_fst_la_LDFLAGS = -module diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/lookahead/Makefile.in b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/lookahead/Makefile.in new file mode 100644 index 0000000000..629216cc8a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/lookahead/Makefile.in @@ -0,0 +1,748 @@ +# Makefile.in generated by automake 1.14.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2013 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +VPATH = @srcdir@ +am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +subdir = src/extensions/lookahead +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ + $(top_srcdir)/depcomp +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \ + $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ + $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ + $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h \ + $(top_builddir)/src/include/fst/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__uninstall_files_from_dir = { \ + test -z "$$files" \ + || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && rm -f $$files; }; \ + } +am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)" +LTLIBRARIES = $(lib_LTLIBRARIES) $(libfst_LTLIBRARIES) +arc_lookahead_fst_la_LIBADD = +am_arc_lookahead_fst_la_OBJECTS = arc_lookahead-fst.lo +arc_lookahead_fst_la_OBJECTS = $(am_arc_lookahead_fst_la_OBJECTS) +AM_V_lt = $(am__v_lt_@AM_V@) +am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) +am__v_lt_0 = --silent +am__v_lt_1 = +arc_lookahead_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) $(arc_lookahead_fst_la_LDFLAGS) \ + $(LDFLAGS) -o $@ +ilabel_lookahead_fst_la_LIBADD = +am_ilabel_lookahead_fst_la_OBJECTS = ilabel_lookahead-fst.lo +ilabel_lookahead_fst_la_OBJECTS = \ + $(am_ilabel_lookahead_fst_la_OBJECTS) +ilabel_lookahead_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) $(ilabel_lookahead_fst_la_LDFLAGS) \ + $(LDFLAGS) -o $@ +am__DEPENDENCIES_1 = +libfstlookahead_la_DEPENDENCIES = ../../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am_libfstlookahead_la_OBJECTS = arc_lookahead-fst.lo \ + ilabel_lookahead-fst.lo olabel_lookahead-fst.lo +libfstlookahead_la_OBJECTS = $(am_libfstlookahead_la_OBJECTS) +libfstlookahead_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) $(libfstlookahead_la_LDFLAGS) \ + $(LDFLAGS) -o $@ +olabel_lookahead_fst_la_LIBADD = +am_olabel_lookahead_fst_la_OBJECTS = olabel_lookahead-fst.lo +olabel_lookahead_fst_la_OBJECTS = \ + $(am_olabel_lookahead_fst_la_OBJECTS) +olabel_lookahead_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) $(olabel_lookahead_fst_la_LDFLAGS) \ + $(LDFLAGS) -o $@ +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +DEFAULT_INCLUDES = +depcomp = $(SHELL) $(top_srcdir)/depcomp +am__depfiles_maybe = depfiles +am__mv = mv -f +CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CXXFLAGS) $(CXXFLAGS) +AM_V_CXX = $(am__v_CXX_@AM_V@) +am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@) +am__v_CXX_0 = @echo " CXX " $@; +am__v_CXX_1 = +CXXLD = $(CXX) +CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_CXXLD = $(am__v_CXXLD_@AM_V@) +am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@) +am__v_CXXLD_0 = @echo " CXXLD " $@; +am__v_CXXLD_1 = +SOURCES = $(arc_lookahead_fst_la_SOURCES) \ + $(ilabel_lookahead_fst_la_SOURCES) \ + $(libfstlookahead_la_SOURCES) \ + $(olabel_lookahead_fst_la_SOURCES) +DIST_SOURCES = $(arc_lookahead_fst_la_SOURCES) \ + $(ilabel_lookahead_fst_la_SOURCES) \ + $(libfstlookahead_la_SOURCES) \ + $(olabel_lookahead_fst_la_SOURCES) +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DL_LIBS = @DL_LIBS@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PYTHON = @PYTHON@ +PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@ +PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ +PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@ +PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@ +PYTHON_LDFLAGS = @PYTHON_LDFLAGS@ +PYTHON_PLATFORM = @PYTHON_PLATFORM@ +PYTHON_PREFIX = @PYTHON_PREFIX@ +PYTHON_SITE_PKG = @PYTHON_SITE_PKG@ +PYTHON_VERSION = @PYTHON_VERSION@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +libfstdir = @libfstdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgpyexecdir = @pkgpyexecdir@ +pkgpythondir = @pkgpythondir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +pyexecdir = @pyexecdir@ +pythondir = @pythondir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) +libfst_LTLIBRARIES = arc_lookahead-fst.la \ +ilabel_lookahead-fst.la olabel_lookahead-fst.la + +lib_LTLIBRARIES = libfstlookahead.la +libfstlookahead_la_SOURCES = arc_lookahead-fst.cc ilabel_lookahead-fst.cc \ + olabel_lookahead-fst.cc + +libfstlookahead_la_LDFLAGS = -version-info 10:0:0 +libfstlookahead_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS) +arc_lookahead_fst_la_SOURCES = arc_lookahead-fst.cc +arc_lookahead_fst_la_LDFLAGS = -module +ilabel_lookahead_fst_la_SOURCES = ilabel_lookahead-fst.cc +ilabel_lookahead_fst_la_LDFLAGS = -module +olabel_lookahead_fst_la_SOURCES = olabel_lookahead-fst.cc +olabel_lookahead_fst_la_LDFLAGS = -module +all: all-am + +.SUFFIXES: +.SUFFIXES: .cc .lo .o .obj +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/lookahead/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign src/extensions/lookahead/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +install-libLTLIBRARIES: $(lib_LTLIBRARIES) + @$(NORMAL_INSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \ + } + +uninstall-libLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \ + done + +clean-libLTLIBRARIES: + -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES) + @list='$(lib_LTLIBRARIES)'; \ + locs=`for p in $$list; do echo $$p; done | \ + sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ + sort -u`; \ + test -z "$$locs" || { \ + echo rm -f $${locs}; \ + rm -f $${locs}; \ + } + +install-libfstLTLIBRARIES: $(libfst_LTLIBRARIES) + @$(NORMAL_INSTALL) + @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(libfstdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(libfstdir)" || exit 1; \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libfstdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libfstdir)"; \ + } + +uninstall-libfstLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libfstdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libfstdir)/$$f"; \ + done + +clean-libfstLTLIBRARIES: + -test -z "$(libfst_LTLIBRARIES)" || rm -f $(libfst_LTLIBRARIES) + @list='$(libfst_LTLIBRARIES)'; \ + locs=`for p in $$list; do echo $$p; done | \ + sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ + sort -u`; \ + test -z "$$locs" || { \ + echo rm -f $${locs}; \ + rm -f $${locs}; \ + } + +arc_lookahead-fst.la: $(arc_lookahead_fst_la_OBJECTS) $(arc_lookahead_fst_la_DEPENDENCIES) $(EXTRA_arc_lookahead_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(arc_lookahead_fst_la_LINK) -rpath $(libfstdir) $(arc_lookahead_fst_la_OBJECTS) $(arc_lookahead_fst_la_LIBADD) $(LIBS) + +ilabel_lookahead-fst.la: $(ilabel_lookahead_fst_la_OBJECTS) $(ilabel_lookahead_fst_la_DEPENDENCIES) $(EXTRA_ilabel_lookahead_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(ilabel_lookahead_fst_la_LINK) -rpath $(libfstdir) $(ilabel_lookahead_fst_la_OBJECTS) $(ilabel_lookahead_fst_la_LIBADD) $(LIBS) + +libfstlookahead.la: $(libfstlookahead_la_OBJECTS) $(libfstlookahead_la_DEPENDENCIES) $(EXTRA_libfstlookahead_la_DEPENDENCIES) + $(AM_V_CXXLD)$(libfstlookahead_la_LINK) -rpath $(libdir) $(libfstlookahead_la_OBJECTS) $(libfstlookahead_la_LIBADD) $(LIBS) + +olabel_lookahead-fst.la: $(olabel_lookahead_fst_la_OBJECTS) $(olabel_lookahead_fst_la_DEPENDENCIES) $(EXTRA_olabel_lookahead_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(olabel_lookahead_fst_la_LINK) -rpath $(libfstdir) $(olabel_lookahead_fst_la_OBJECTS) $(olabel_lookahead_fst_la_LIBADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/arc_lookahead-fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ilabel_lookahead-fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/olabel_lookahead-fst.Plo@am__quote@ + +.cc.o: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $< + +.cc.obj: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cc.lo: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ +@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $< + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-am +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-am + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscopelist: cscopelist-am + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(LTLIBRARIES) +installdirs: + for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic clean-libLTLIBRARIES clean-libfstLTLIBRARIES \ + clean-libtool mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: install-libfstLTLIBRARIES + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: install-libLTLIBRARIES + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-libLTLIBRARIES uninstall-libfstLTLIBRARIES + +.MAKE: install-am install-strip + +.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \ + clean-libLTLIBRARIES clean-libfstLTLIBRARIES clean-libtool \ + cscopelist-am ctags ctags-am distclean distclean-compile \ + distclean-generic distclean-libtool distclean-tags distdir dvi \ + dvi-am html html-am info info-am install install-am \ + install-data install-data-am install-dvi install-dvi-am \ + install-exec install-exec-am install-html install-html-am \ + install-info install-info-am install-libLTLIBRARIES \ + install-libfstLTLIBRARIES install-man install-pdf \ + install-pdf-am install-ps install-ps-am install-strip \ + installcheck installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-compile \ + mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ + tags tags-am uninstall uninstall-am uninstall-libLTLIBRARIES \ + uninstall-libfstLTLIBRARIES + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/lookahead/arc_lookahead-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/lookahead/arc_lookahead-fst.cc new file mode 100644 index 0000000000..63b16e4c47 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/lookahead/arc_lookahead-fst.cc @@ -0,0 +1,19 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { + +static FstRegisterer ArcLookAheadFst_StdArc_registerer; +static FstRegisterer, ArcLookAheadMatcher>>, + arc_lookahead_fst_type>> + ArcLookAheadFst_LogArc_registerer; +static FstRegisterer, ArcLookAheadMatcher>>, + arc_lookahead_fst_type>> + ArcLookAheadFst_Log64Arc_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/lookahead/ilabel_lookahead-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/lookahead/ilabel_lookahead-fst.cc new file mode 100644 index 0000000000..5b7fa69dfb --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/lookahead/ilabel_lookahead-fst.cc @@ -0,0 +1,24 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { + +static FstRegisterer + ILabelLookAheadFst_StdArc_registerer; +static FstRegisterer, + LabelLookAheadMatcher>, + ilabel_lookahead_flags, FastLogAccumulator>, + ilabel_lookahead_fst_type, LabelLookAheadRelabeler>> + ILabelLookAheadFst_LogArc_registerer; +static FstRegisterer, + LabelLookAheadMatcher>, + ilabel_lookahead_flags, FastLogAccumulator>, + ilabel_lookahead_fst_type, LabelLookAheadRelabeler>> + ILabelLookAheadFst_Log64Arc_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/lookahead/olabel_lookahead-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/lookahead/olabel_lookahead-fst.cc new file mode 100644 index 0000000000..9d3067fd81 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/lookahead/olabel_lookahead-fst.cc @@ -0,0 +1,24 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { + +static FstRegisterer + OLabelLookAheadFst_StdArc_registerer; +static FstRegisterer, + LabelLookAheadMatcher>, + olabel_lookahead_flags, FastLogAccumulator>, + olabel_lookahead_fst_type, LabelLookAheadRelabeler>> + OLabelLookAheadFst_LogArc_registerer; +static FstRegisterer, + LabelLookAheadMatcher>, + olabel_lookahead_flags, FastLogAccumulator>, + olabel_lookahead_fst_type, LabelLookAheadRelabeler>> + OLabelLookAheadFst_Log64Arc_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/mpdt/Makefile.am b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/mpdt/Makefile.am new file mode 100644 index 0000000000..c586b2d047 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/mpdt/Makefile.am @@ -0,0 +1,26 @@ +AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) + +if HAVE_BIN +bin_PROGRAMS = mpdtcompose mpdtexpand mpdtinfo mpdtreverse + +LDADD = libfstmpdtscript.la \ + ../pdt/libfstpdtscript.la \ + ../../script/libfstscript.la \ + ../../lib/libfst.la -lm $(DL_LIBS) + +mpdtcompose_SOURCES = mpdtcompose.cc + +mpdtexpand_SOURCES = mpdtexpand.cc + +mpdtinfo_SOURCES = mpdtinfo.cc + +mpdtreverse_SOURCES = mpdtreverse.cc +endif + +if HAVE_SCRIPT +lib_LTLIBRARIES = libfstmpdtscript.la +libfstmpdtscript_la_SOURCES = mpdtscript.cc +libfstmpdtscript_la_LDFLAGS = -version-info 10:0:0 +libfstmpdtscript_la_LIBADD = ../../script/libfstscript.la \ + ../../lib/libfst.la -lm $(DL_LIBS) +endif diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/mpdt/Makefile.in b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/mpdt/Makefile.in new file mode 100644 index 0000000000..a090d3bdaf --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/mpdt/Makefile.in @@ -0,0 +1,786 @@ +# Makefile.in generated by automake 1.14.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2013 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + + +VPATH = @srcdir@ +am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +@HAVE_BIN_TRUE@bin_PROGRAMS = mpdtcompose$(EXEEXT) mpdtexpand$(EXEEXT) \ +@HAVE_BIN_TRUE@ mpdtinfo$(EXEEXT) mpdtreverse$(EXEEXT) +subdir = src/extensions/mpdt +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ + $(top_srcdir)/depcomp +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \ + $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ + $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ + $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h \ + $(top_builddir)/src/include/fst/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__uninstall_files_from_dir = { \ + test -z "$$files" \ + || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && rm -f $$files; }; \ + } +am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(bindir)" +LTLIBRARIES = $(lib_LTLIBRARIES) +am__DEPENDENCIES_1 = +@HAVE_SCRIPT_TRUE@libfstmpdtscript_la_DEPENDENCIES = \ +@HAVE_SCRIPT_TRUE@ ../../script/libfstscript.la \ +@HAVE_SCRIPT_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +am__libfstmpdtscript_la_SOURCES_DIST = mpdtscript.cc +@HAVE_SCRIPT_TRUE@am_libfstmpdtscript_la_OBJECTS = mpdtscript.lo +libfstmpdtscript_la_OBJECTS = $(am_libfstmpdtscript_la_OBJECTS) +AM_V_lt = $(am__v_lt_@AM_V@) +am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) +am__v_lt_0 = --silent +am__v_lt_1 = +libfstmpdtscript_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) $(libfstmpdtscript_la_LDFLAGS) \ + $(LDFLAGS) -o $@ +@HAVE_SCRIPT_TRUE@am_libfstmpdtscript_la_rpath = -rpath $(libdir) +PROGRAMS = $(bin_PROGRAMS) +am__mpdtcompose_SOURCES_DIST = mpdtcompose.cc +@HAVE_BIN_TRUE@am_mpdtcompose_OBJECTS = mpdtcompose.$(OBJEXT) +mpdtcompose_OBJECTS = $(am_mpdtcompose_OBJECTS) +mpdtcompose_LDADD = $(LDADD) +@HAVE_BIN_TRUE@mpdtcompose_DEPENDENCIES = libfstmpdtscript.la \ +@HAVE_BIN_TRUE@ ../pdt/libfstpdtscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +am__mpdtexpand_SOURCES_DIST = mpdtexpand.cc +@HAVE_BIN_TRUE@am_mpdtexpand_OBJECTS = mpdtexpand.$(OBJEXT) +mpdtexpand_OBJECTS = $(am_mpdtexpand_OBJECTS) +mpdtexpand_LDADD = $(LDADD) +@HAVE_BIN_TRUE@mpdtexpand_DEPENDENCIES = libfstmpdtscript.la \ +@HAVE_BIN_TRUE@ ../pdt/libfstpdtscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +am__mpdtinfo_SOURCES_DIST = mpdtinfo.cc +@HAVE_BIN_TRUE@am_mpdtinfo_OBJECTS = mpdtinfo.$(OBJEXT) +mpdtinfo_OBJECTS = $(am_mpdtinfo_OBJECTS) +mpdtinfo_LDADD = $(LDADD) +@HAVE_BIN_TRUE@mpdtinfo_DEPENDENCIES = libfstmpdtscript.la \ +@HAVE_BIN_TRUE@ ../pdt/libfstpdtscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +am__mpdtreverse_SOURCES_DIST = mpdtreverse.cc +@HAVE_BIN_TRUE@am_mpdtreverse_OBJECTS = mpdtreverse.$(OBJEXT) +mpdtreverse_OBJECTS = $(am_mpdtreverse_OBJECTS) +mpdtreverse_LDADD = $(LDADD) +@HAVE_BIN_TRUE@mpdtreverse_DEPENDENCIES = libfstmpdtscript.la \ +@HAVE_BIN_TRUE@ ../pdt/libfstpdtscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +DEFAULT_INCLUDES = +depcomp = $(SHELL) $(top_srcdir)/depcomp +am__depfiles_maybe = depfiles +am__mv = mv -f +CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CXXFLAGS) $(CXXFLAGS) +AM_V_CXX = $(am__v_CXX_@AM_V@) +am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@) +am__v_CXX_0 = @echo " CXX " $@; +am__v_CXX_1 = +CXXLD = $(CXX) +CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_CXXLD = $(am__v_CXXLD_@AM_V@) +am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@) +am__v_CXXLD_0 = @echo " CXXLD " $@; +am__v_CXXLD_1 = +SOURCES = $(libfstmpdtscript_la_SOURCES) $(mpdtcompose_SOURCES) \ + $(mpdtexpand_SOURCES) $(mpdtinfo_SOURCES) \ + $(mpdtreverse_SOURCES) +DIST_SOURCES = $(am__libfstmpdtscript_la_SOURCES_DIST) \ + $(am__mpdtcompose_SOURCES_DIST) $(am__mpdtexpand_SOURCES_DIST) \ + $(am__mpdtinfo_SOURCES_DIST) $(am__mpdtreverse_SOURCES_DIST) +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DL_LIBS = @DL_LIBS@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PYTHON = @PYTHON@ +PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@ +PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ +PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@ +PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@ +PYTHON_LDFLAGS = @PYTHON_LDFLAGS@ +PYTHON_PLATFORM = @PYTHON_PLATFORM@ +PYTHON_PREFIX = @PYTHON_PREFIX@ +PYTHON_SITE_PKG = @PYTHON_SITE_PKG@ +PYTHON_VERSION = @PYTHON_VERSION@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +libfstdir = @libfstdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgpyexecdir = @pkgpyexecdir@ +pkgpythondir = @pkgpythondir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +pyexecdir = @pyexecdir@ +pythondir = @pythondir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) +@HAVE_BIN_TRUE@LDADD = libfstmpdtscript.la \ +@HAVE_BIN_TRUE@ ../pdt/libfstpdtscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la -lm $(DL_LIBS) + +@HAVE_BIN_TRUE@mpdtcompose_SOURCES = mpdtcompose.cc +@HAVE_BIN_TRUE@mpdtexpand_SOURCES = mpdtexpand.cc +@HAVE_BIN_TRUE@mpdtinfo_SOURCES = mpdtinfo.cc +@HAVE_BIN_TRUE@mpdtreverse_SOURCES = mpdtreverse.cc +@HAVE_SCRIPT_TRUE@lib_LTLIBRARIES = libfstmpdtscript.la +@HAVE_SCRIPT_TRUE@libfstmpdtscript_la_SOURCES = mpdtscript.cc +@HAVE_SCRIPT_TRUE@libfstmpdtscript_la_LDFLAGS = -version-info 10:0:0 +@HAVE_SCRIPT_TRUE@libfstmpdtscript_la_LIBADD = ../../script/libfstscript.la \ +@HAVE_SCRIPT_TRUE@ ../../lib/libfst.la -lm $(DL_LIBS) + +all: all-am + +.SUFFIXES: +.SUFFIXES: .cc .lo .o .obj +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/mpdt/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign src/extensions/mpdt/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +install-libLTLIBRARIES: $(lib_LTLIBRARIES) + @$(NORMAL_INSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \ + } + +uninstall-libLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \ + done + +clean-libLTLIBRARIES: + -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES) + @list='$(lib_LTLIBRARIES)'; \ + locs=`for p in $$list; do echo $$p; done | \ + sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ + sort -u`; \ + test -z "$$locs" || { \ + echo rm -f $${locs}; \ + rm -f $${locs}; \ + } + +libfstmpdtscript.la: $(libfstmpdtscript_la_OBJECTS) $(libfstmpdtscript_la_DEPENDENCIES) $(EXTRA_libfstmpdtscript_la_DEPENDENCIES) + $(AM_V_CXXLD)$(libfstmpdtscript_la_LINK) $(am_libfstmpdtscript_la_rpath) $(libfstmpdtscript_la_OBJECTS) $(libfstmpdtscript_la_LIBADD) $(LIBS) +install-binPROGRAMS: $(bin_PROGRAMS) + @$(NORMAL_INSTALL) + @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \ + if test -n "$$list"; then \ + echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \ + fi; \ + for p in $$list; do echo "$$p $$p"; done | \ + sed 's/$(EXEEXT)$$//' | \ + while read p p1; do if test -f $$p \ + || test -f $$p1 \ + ; then echo "$$p"; echo "$$p"; else :; fi; \ + done | \ + sed -e 'p;s,.*/,,;n;h' \ + -e 's|.*|.|' \ + -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \ + sed 'N;N;N;s,\n, ,g' | \ + $(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \ + { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \ + if ($$2 == $$4) files[d] = files[d] " " $$1; \ + else { print "f", $$3 "/" $$4, $$1; } } \ + END { for (d in files) print "f", d, files[d] }' | \ + while read type dir files; do \ + if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \ + test -z "$$files" || { \ + echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \ + $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \ + } \ + ; done + +uninstall-binPROGRAMS: + @$(NORMAL_UNINSTALL) + @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \ + files=`for p in $$list; do echo "$$p"; done | \ + sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \ + -e 's/$$/$(EXEEXT)/' \ + `; \ + test -n "$$list" || exit 0; \ + echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(bindir)" && rm -f $$files + +clean-binPROGRAMS: + @list='$(bin_PROGRAMS)'; test -n "$$list" || exit 0; \ + echo " rm -f" $$list; \ + rm -f $$list || exit $$?; \ + test -n "$(EXEEXT)" || exit 0; \ + list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \ + echo " rm -f" $$list; \ + rm -f $$list + +mpdtcompose$(EXEEXT): $(mpdtcompose_OBJECTS) $(mpdtcompose_DEPENDENCIES) $(EXTRA_mpdtcompose_DEPENDENCIES) + @rm -f mpdtcompose$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(mpdtcompose_OBJECTS) $(mpdtcompose_LDADD) $(LIBS) + +mpdtexpand$(EXEEXT): $(mpdtexpand_OBJECTS) $(mpdtexpand_DEPENDENCIES) $(EXTRA_mpdtexpand_DEPENDENCIES) + @rm -f mpdtexpand$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(mpdtexpand_OBJECTS) $(mpdtexpand_LDADD) $(LIBS) + +mpdtinfo$(EXEEXT): $(mpdtinfo_OBJECTS) $(mpdtinfo_DEPENDENCIES) $(EXTRA_mpdtinfo_DEPENDENCIES) + @rm -f mpdtinfo$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(mpdtinfo_OBJECTS) $(mpdtinfo_LDADD) $(LIBS) + +mpdtreverse$(EXEEXT): $(mpdtreverse_OBJECTS) $(mpdtreverse_DEPENDENCIES) $(EXTRA_mpdtreverse_DEPENDENCIES) + @rm -f mpdtreverse$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(mpdtreverse_OBJECTS) $(mpdtreverse_LDADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mpdtcompose.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mpdtexpand.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mpdtinfo.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mpdtreverse.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mpdtscript.Plo@am__quote@ + +.cc.o: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $< + +.cc.obj: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cc.lo: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ +@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $< + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-am +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-am + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscopelist: cscopelist-am + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(LTLIBRARIES) $(PROGRAMS) +install-binPROGRAMS: install-libLTLIBRARIES + +installdirs: + for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(bindir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \ + clean-libtool mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: install-binPROGRAMS install-libLTLIBRARIES + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-binPROGRAMS uninstall-libLTLIBRARIES + +.MAKE: install-am install-strip + +.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \ + clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \ + clean-libtool cscopelist-am ctags ctags-am distclean \ + distclean-compile distclean-generic distclean-libtool \ + distclean-tags distdir dvi dvi-am html html-am info info-am \ + install install-am install-binPROGRAMS install-data \ + install-data-am install-dvi install-dvi-am install-exec \ + install-exec-am install-html install-html-am install-info \ + install-info-am install-libLTLIBRARIES install-man install-pdf \ + install-pdf-am install-ps install-ps-am install-strip \ + installcheck installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-compile \ + mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ + tags tags-am uninstall uninstall-am uninstall-binPROGRAMS \ + uninstall-libLTLIBRARIES + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/mpdt/mpdtcompose.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/mpdt/mpdtcompose.cc new file mode 100644 index 0000000000..351033af59 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/mpdt/mpdtcompose.cc @@ -0,0 +1,89 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Composes an MPDT and an FST. + +#include + +#include +#include +#include + +#include +#include + +#include +#include +#include +#include + +DEFINE_string(mpdt_parentheses, "", + "MPDT parenthesis label pairs with assignments"); +DEFINE_bool(left_mpdt, true, "Is the first argument the MPDT?"); +DEFINE_bool(connect, true, "Trim output?"); +DEFINE_string(compose_filter, "paren", + "Composition filter, one of: \"expand\", \"expand_paren\", " + "\"paren\""); + +int main(int argc, char **argv) { + namespace s = fst::script; + using fst::MPdtComposeOptions; + using fst::PdtComposeFilter; + using fst::ReadLabelTriples; + using fst::script::FstClass; + using fst::script::VectorFstClass; + + string usage = "Compose an MPDT and an FST.\n\n Usage: "; + usage += argv[0]; + usage += " in.pdt in.fst [out.mpdt]\n"; + usage += " in.fst in.pdt [out.mpdt]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc < 3 || argc > 4) { + ShowUsage(); + return 1; + } + + const string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1]; + const string in2_name = strcmp(argv[2], "-") == 0 ? "" : argv[2]; + const string out_name = argc > 3 ? argv[3] : ""; + + if (in1_name.empty() && in2_name.empty()) { + LOG(ERROR) << argv[0] << ": Can't take both inputs from standard input."; + return 1; + } + + std::unique_ptr ifst1(FstClass::Read(in1_name)); + if (!ifst1) return 1; + std::unique_ptr ifst2(FstClass::Read(in2_name)); + if (!ifst2) return 1; + + if (FLAGS_mpdt_parentheses.empty()) { + LOG(ERROR) << argv[0] << ": No MPDT parenthesis label pairs provided"; + return 1; + } + + std::vector parens; + std::vector assignments; + if (!ReadLabelTriples(FLAGS_mpdt_parentheses, &parens, &assignments, false)) + return 1; + + VectorFstClass ofst(ifst1->ArcType()); + + PdtComposeFilter compose_filter; + if (!s::GetPdtComposeFilter(FLAGS_compose_filter, &compose_filter)) { + LOG(ERROR) << argv[0] << ": Unknown or unsupported compose filter type: " + << FLAGS_compose_filter; + return 1; + } + + const MPdtComposeOptions opts(FLAGS_connect, compose_filter); + + s::MPdtCompose(*ifst1, *ifst2, parens, assignments, &ofst, opts, + FLAGS_left_mpdt); + + ofst.Write(out_name); + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/mpdt/mpdtexpand.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/mpdt/mpdtexpand.cc new file mode 100644 index 0000000000..fb24b3ac7d --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/mpdt/mpdtexpand.cc @@ -0,0 +1,68 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Expands a (bounded-stack) MPDT as an FST. + +#include + +#include +#include +#include + +#include +#include + +#include +#include +#include + +DEFINE_string(mpdt_parentheses, "", + "MPDT parenthesis label pairs with assignments"); +DEFINE_bool(connect, true, "Trim output?"); +DEFINE_bool(keep_parentheses, false, "Keep PDT parentheses in result?"); + +int main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + using fst::script::VectorFstClass; + using fst::ReadLabelTriples; + using fst::MPdtExpandOptions; + + string usage = "Expand a (bounded-stack) MPDT as an FST.\n\n Usage: "; + usage += argv[0]; + usage += " in.pdt [out.fst]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = + (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr ifst(FstClass::Read(in_name)); + if (!ifst) return 1; + + if (FLAGS_mpdt_parentheses.empty()) { + LOG(ERROR) << argv[0] << ": No MPDT parenthesis label pairs provided"; + return 1; + } + + std::vector parens; + std::vector assignments; + if (!ReadLabelTriples(FLAGS_mpdt_parentheses, &parens, &assignments, false)) + return 1; + + VectorFstClass ofst(ifst->ArcType()); + + const MPdtExpandOptions opts(FLAGS_connect, FLAGS_keep_parentheses); + + s::MPdtExpand(*ifst, parens, assignments, &ofst, opts); + + ofst.Write(out_name); + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/mpdt/mpdtinfo.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/mpdt/mpdtinfo.cc new file mode 100644 index 0000000000..b8d7d4a358 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/mpdt/mpdtinfo.cc @@ -0,0 +1,58 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Prints out various information about an MPDT such as number of states, arcs, +// and parentheses. + +#include + +#include +#include +#include + +#include +#include + +#include +#include +#include + +DEFINE_string(mpdt_parentheses, "", + "MPDT parenthesis label pairs with assignments"); + +int main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + using fst::ReadLabelTriples; + + string usage = "Prints out information about an MPDT.\n\n Usage: "; + usage += argv[0]; + usage += " in.pdt\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 2) { + ShowUsage(); + return 1; + } + + const string in_name = + (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : ""; + + std::unique_ptr ifst(FstClass::Read(in_name)); + if (!ifst) return 1; + + if (FLAGS_mpdt_parentheses.empty()) { + LOG(ERROR) << argv[0] << ": No MPDT parenthesis label pairs provided"; + return 1; + } + + std::vector parens; + std::vector assignments; + if (!ReadLabelTriples(FLAGS_mpdt_parentheses, &parens, &assignments, false)) + return 1; + + s::PrintMPdtInfo(*ifst, parens, assignments); + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/mpdt/mpdtreverse.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/mpdt/mpdtreverse.cc new file mode 100644 index 0000000000..7bde1a1972 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/mpdt/mpdtreverse.cc @@ -0,0 +1,75 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Reverses an MPDT. + +#include + +#include +#include +#include + +#include +#include + +#include +#include +#include + +DEFINE_string(mpdt_parentheses, "", + "MPDT parenthesis label pairs with assignments."); + +DEFINE_string(mpdt_new_parentheses, "", + "Output for reassigned parentheses and stacks"); + +int main(int argc, char **argv) { + namespace s = fst::script; + using fst::ReadLabelTriples; + using fst::WriteLabelTriples; + using fst::script::FstClass; + using fst::script::VectorFstClass; + + string usage = "Reverse an MPDT.\n\n Usage: "; + usage += argv[0]; + usage += " in.pdt [out.fst]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = + (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr ifst(FstClass::Read(in_name)); + if (!ifst) return 1; + + if (FLAGS_mpdt_parentheses.empty()) { + LOG(ERROR) << argv[0] << ": No MPDT parenthesis label pairs provided"; + return 1; + } + + if (FLAGS_mpdt_new_parentheses.empty()) { + LOG(ERROR) << argv[0] << ": No MPDT output parenthesis label file provided"; + return 1; + } + + std::vector parens; + std::vector assignments; + if (!ReadLabelTriples(FLAGS_mpdt_parentheses, &parens, &assignments, false)) + return 1; + + VectorFstClass ofst(ifst->ArcType()); + + s::MPdtReverse(*ifst, parens, &assignments, &ofst); + + ofst.Write(out_name); + + if (!WriteLabelTriples(FLAGS_mpdt_new_parentheses, parens, assignments)) + return 1; + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/mpdt/mpdtscript.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/mpdt/mpdtscript.cc new file mode 100644 index 0000000000..7573494eb3 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/mpdt/mpdtscript.cc @@ -0,0 +1,65 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Definitions of 'scriptable' versions of mpdt operations, that is, +// those that can be called with FstClass-type arguments. +// +// See comments in nlp/fst/script/script-impl.h for how the registration +// mechanism allows these to work with various arc types. + +#include +#include + +#include +#include +#include +#include +#include + +namespace fst { +namespace script { + +void MPdtCompose(const FstClass &ifst1, const FstClass &ifst2, + const std::vector &parens, + const std::vector &assignments, MutableFstClass *ofst, + const MPdtComposeOptions &copts, bool left_pdt) { + if (!internal::ArcTypesMatch(ifst1, ifst2, "MPdtCompose") || + !internal::ArcTypesMatch(ifst1, *ofst, "MPdtCompose")) return; + MPdtComposeArgs args(ifst1, ifst2, parens, assignments, ofst, copts, + left_pdt); + Apply>("MPdtCompose", ifst1.ArcType(), &args); +} + +void MPdtExpand(const FstClass &ifst, const std::vector &parens, + const std::vector &assignments, MutableFstClass *ofst, + const MPdtExpandOptions &opts) { + MPdtExpandArgs args(ifst, parens, assignments, ofst, opts); + Apply>("MPdtExpand", ifst.ArcType(), &args); +} + +void MPdtExpand(const FstClass &ifst, const std::vector &parens, + const std::vector &assignments, MutableFstClass *ofst, + bool connect) { + MPdtExpand(ifst, parens, assignments, ofst, MPdtExpandOptions(connect)); +} + +void MPdtReverse(const FstClass &ifst, const std::vector &parens, + std::vector *assignments, MutableFstClass *ofst) { + MPdtReverseArgs args(ifst, parens, assignments, ofst); + Apply>("MPdtReverse", ifst.ArcType(), &args); +} + +void PrintMPdtInfo(const FstClass &ifst, const std::vector &parens, + const std::vector &assignments) { + PrintMPdtInfoArgs args(ifst, parens, assignments); + Apply>("PrintMPdtInfo", ifst.ArcType(), &args); +} + +// Register operations for common arc types. + +REGISTER_FST_MPDT_OPERATIONS(StdArc); +REGISTER_FST_MPDT_OPERATIONS(LogArc); +REGISTER_FST_MPDT_OPERATIONS(Log64Arc); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/ngram/Makefile.am b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/ngram/Makefile.am new file mode 100644 index 0000000000..94723d05c8 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/ngram/Makefile.am @@ -0,0 +1,13 @@ +AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) + +libfstdir = @libfstdir@ +libfst_LTLIBRARIES = ngram-fst.la + +lib_LTLIBRARIES = libfstngram.la + +ngram_fst_la_SOURCES = bitmap-index.cc ngram-fst.cc nthbit.cc +ngram_fst_la_LDFLAGS = -module + +libfstngram_la_SOURCES = bitmap-index.cc ngram-fst.cc nthbit.cc +libfstngram_la_LDFLAGS = -version-info 10:0:0 +libfstngram_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS) diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/ngram/Makefile.in b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/ngram/Makefile.in new file mode 100644 index 0000000000..cacc630c59 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/ngram/Makefile.in @@ -0,0 +1,710 @@ +# Makefile.in generated by automake 1.14.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2013 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +VPATH = @srcdir@ +am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +subdir = src/extensions/ngram +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ + $(top_srcdir)/depcomp +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \ + $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ + $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ + $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h \ + $(top_builddir)/src/include/fst/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__uninstall_files_from_dir = { \ + test -z "$$files" \ + || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && rm -f $$files; }; \ + } +am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)" +LTLIBRARIES = $(lib_LTLIBRARIES) $(libfst_LTLIBRARIES) +am__DEPENDENCIES_1 = +libfstngram_la_DEPENDENCIES = ../../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am_libfstngram_la_OBJECTS = bitmap-index.lo ngram-fst.lo nthbit.lo +libfstngram_la_OBJECTS = $(am_libfstngram_la_OBJECTS) +AM_V_lt = $(am__v_lt_@AM_V@) +am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) +am__v_lt_0 = --silent +am__v_lt_1 = +libfstngram_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) $(libfstngram_la_LDFLAGS) \ + $(LDFLAGS) -o $@ +ngram_fst_la_LIBADD = +am_ngram_fst_la_OBJECTS = bitmap-index.lo ngram-fst.lo nthbit.lo +ngram_fst_la_OBJECTS = $(am_ngram_fst_la_OBJECTS) +ngram_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(ngram_fst_la_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +DEFAULT_INCLUDES = +depcomp = $(SHELL) $(top_srcdir)/depcomp +am__depfiles_maybe = depfiles +am__mv = mv -f +CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CXXFLAGS) $(CXXFLAGS) +AM_V_CXX = $(am__v_CXX_@AM_V@) +am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@) +am__v_CXX_0 = @echo " CXX " $@; +am__v_CXX_1 = +CXXLD = $(CXX) +CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_CXXLD = $(am__v_CXXLD_@AM_V@) +am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@) +am__v_CXXLD_0 = @echo " CXXLD " $@; +am__v_CXXLD_1 = +SOURCES = $(libfstngram_la_SOURCES) $(ngram_fst_la_SOURCES) +DIST_SOURCES = $(libfstngram_la_SOURCES) $(ngram_fst_la_SOURCES) +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DL_LIBS = @DL_LIBS@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PYTHON = @PYTHON@ +PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@ +PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ +PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@ +PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@ +PYTHON_LDFLAGS = @PYTHON_LDFLAGS@ +PYTHON_PLATFORM = @PYTHON_PLATFORM@ +PYTHON_PREFIX = @PYTHON_PREFIX@ +PYTHON_SITE_PKG = @PYTHON_SITE_PKG@ +PYTHON_VERSION = @PYTHON_VERSION@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +libfstdir = @libfstdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgpyexecdir = @pkgpyexecdir@ +pkgpythondir = @pkgpythondir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +pyexecdir = @pyexecdir@ +pythondir = @pythondir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) +libfst_LTLIBRARIES = ngram-fst.la +lib_LTLIBRARIES = libfstngram.la +ngram_fst_la_SOURCES = bitmap-index.cc ngram-fst.cc nthbit.cc +ngram_fst_la_LDFLAGS = -module +libfstngram_la_SOURCES = bitmap-index.cc ngram-fst.cc nthbit.cc +libfstngram_la_LDFLAGS = -version-info 10:0:0 +libfstngram_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS) +all: all-am + +.SUFFIXES: +.SUFFIXES: .cc .lo .o .obj +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/ngram/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign src/extensions/ngram/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +install-libLTLIBRARIES: $(lib_LTLIBRARIES) + @$(NORMAL_INSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \ + } + +uninstall-libLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \ + done + +clean-libLTLIBRARIES: + -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES) + @list='$(lib_LTLIBRARIES)'; \ + locs=`for p in $$list; do echo $$p; done | \ + sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ + sort -u`; \ + test -z "$$locs" || { \ + echo rm -f $${locs}; \ + rm -f $${locs}; \ + } + +install-libfstLTLIBRARIES: $(libfst_LTLIBRARIES) + @$(NORMAL_INSTALL) + @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(libfstdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(libfstdir)" || exit 1; \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libfstdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libfstdir)"; \ + } + +uninstall-libfstLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libfstdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libfstdir)/$$f"; \ + done + +clean-libfstLTLIBRARIES: + -test -z "$(libfst_LTLIBRARIES)" || rm -f $(libfst_LTLIBRARIES) + @list='$(libfst_LTLIBRARIES)'; \ + locs=`for p in $$list; do echo $$p; done | \ + sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ + sort -u`; \ + test -z "$$locs" || { \ + echo rm -f $${locs}; \ + rm -f $${locs}; \ + } + +libfstngram.la: $(libfstngram_la_OBJECTS) $(libfstngram_la_DEPENDENCIES) $(EXTRA_libfstngram_la_DEPENDENCIES) + $(AM_V_CXXLD)$(libfstngram_la_LINK) -rpath $(libdir) $(libfstngram_la_OBJECTS) $(libfstngram_la_LIBADD) $(LIBS) + +ngram-fst.la: $(ngram_fst_la_OBJECTS) $(ngram_fst_la_DEPENDENCIES) $(EXTRA_ngram_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(ngram_fst_la_LINK) -rpath $(libfstdir) $(ngram_fst_la_OBJECTS) $(ngram_fst_la_LIBADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bitmap-index.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ngram-fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nthbit.Plo@am__quote@ + +.cc.o: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $< + +.cc.obj: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cc.lo: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ +@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $< + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-am +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-am + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscopelist: cscopelist-am + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(LTLIBRARIES) +installdirs: + for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic clean-libLTLIBRARIES clean-libfstLTLIBRARIES \ + clean-libtool mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: install-libfstLTLIBRARIES + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: install-libLTLIBRARIES + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-libLTLIBRARIES uninstall-libfstLTLIBRARIES + +.MAKE: install-am install-strip + +.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \ + clean-libLTLIBRARIES clean-libfstLTLIBRARIES clean-libtool \ + cscopelist-am ctags ctags-am distclean distclean-compile \ + distclean-generic distclean-libtool distclean-tags distdir dvi \ + dvi-am html html-am info info-am install install-am \ + install-data install-data-am install-dvi install-dvi-am \ + install-exec install-exec-am install-html install-html-am \ + install-info install-info-am install-libLTLIBRARIES \ + install-libfstLTLIBRARIES install-man install-pdf \ + install-pdf-am install-ps install-ps-am install-strip \ + installcheck installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-compile \ + mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ + tags tags-am uninstall uninstall-am uninstall-libLTLIBRARIES \ + uninstall-libfstLTLIBRARIES + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/ngram/bitmap-index.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/ngram/bitmap-index.cc new file mode 100644 index 0000000000..b62bb98cae --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/ngram/bitmap-index.cc @@ -0,0 +1,225 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +#include +#include + +#include +#include + +namespace fst { +namespace { +const size_t kPrimaryBlockBits = + BitmapIndex::kStorageBitSize * BitmapIndex::kSecondaryBlockSize; + +// If [begin, begin+size) is a monotonically increasing running sum of +// popcounts for a bitmap, this will return the index of the word that contains +// the value'th zero. If value is larger then the number of zeros in the +// bitmap, size will be returned. The idea is that the number of zerocounts +// (i.e. the popcount of logical NOT of values) is offset * kStorageBitSize +// minus the value for each element of the running sum. +template +size_t InvertedSearch(const Container& c, + size_t first_idx, + size_t last_idx, + size_t value) { + const size_t begin_idx = first_idx; + while (first_idx != last_idx) { + // Invariant: [first_idx, last_idx) is the search range. + size_t mid_idx = first_idx + ((last_idx - first_idx) / 2); + size_t mid_value = BlockSize * (1 + (mid_idx - begin_idx)) - c[mid_idx]; + if (mid_value < value) { + first_idx = mid_idx + 1; + } else { + last_idx = mid_idx; + } + } + return first_idx; +} +} // namespace + +size_t BitmapIndex::Rank1(size_t end) const { + if (end == 0) return 0; + const uint32 end_word = (end - 1) >> BitmapIndex::kStorageLogBitSize; + const uint32 sum = get_index_ones_count(end_word); + const size_t masked = end & kStorageBlockMask; + if (masked == 0) { + return sum + __builtin_popcountll(bits_[end_word]); + } else { + const uint64 zero = 0; + return sum + __builtin_popcountll(bits_[end_word] & + (~zero >> (kStorageBitSize - masked))); + } +} + +size_t BitmapIndex::Select1(size_t bit_index) const { + if (bit_index >= GetOnesCount()) return Bits(); + // search primary index for the relevant block + uint32 rembits = bit_index + 1; + const uint32 block = find_primary_block(bit_index + 1); + uint32 offset = 0; + if (block > 0) { + rembits -= primary_index_[block - 1]; + offset += block * kSecondaryBlockSize; + } + // search the secondary index + uint32 word = find_secondary_block(offset, rembits); + if (word > 0) { + rembits -= secondary_index_[offset + word - 1]; + offset += word; + } + int nth = nth_bit(bits_[offset], rembits); + return (offset << BitmapIndex::kStorageLogBitSize) + nth; +} + +size_t BitmapIndex::Select0(size_t bit_index) const { + if (bit_index >= Bits() - GetOnesCount()) return Bits(); + // search inverted primary index for relevant block + uint32 remzeros = bit_index + 1; + uint32 offset = 0; + const uint32 block = find_inverted_primary_block(bit_index + 1); + if (block > 0) { + remzeros -= kPrimaryBlockBits * block - primary_index_[block - 1]; + offset += block * kSecondaryBlockSize; + } + // search the inverted secondary index + uint32 word = find_inverted_secondary_block(offset, remzeros); + if (word > 0) { + remzeros -= BitmapIndex::kStorageBitSize * word - + secondary_index_[offset + word - 1]; + offset += word; + } + int nth = nth_bit(~bits_[offset], remzeros); + return (offset << BitmapIndex::kStorageLogBitSize) + nth; +} + +std::pair BitmapIndex::Select0s(size_t bit_index) const { + const uint64 zero = 0; + const uint64 ones = ~zero; + size_t zeros_count = Bits() - GetOnesCount(); + if (bit_index >= zeros_count) return std::make_pair(Bits(), Bits()); + if (bit_index + 1 >= zeros_count) { + return std::make_pair(Select0(bit_index), Bits()); + } + // search inverted primary index for relevant block + uint32 remzeros = bit_index + 1; + uint32 offset = 0; + const uint32 block = find_inverted_primary_block(bit_index + 1); + size_t num_zeros_in_block = + kPrimaryBlockBits * (1 + block) - primary_index_[block]; + if (block > 0) { + size_t num_zeros_next = + kPrimaryBlockBits * block - primary_index_[block - 1]; + num_zeros_in_block -= num_zeros_next; + remzeros -= num_zeros_next; + offset += block * kSecondaryBlockSize; + } + // search the inverted secondary index + uint32 word = find_inverted_secondary_block(offset, remzeros); + uint32 sum_zeros_next_word = BitmapIndex::kStorageBitSize * (1 + word) - + secondary_index_[offset + word]; + uint32 sum_zeros_this_word = 0; + if (word > 0) { + sum_zeros_this_word = BitmapIndex::kStorageBitSize * word - + secondary_index_[offset + word - 1]; + remzeros -= sum_zeros_this_word; + offset += word; + } + int nth = nth_bit(~bits_[offset], remzeros); + size_t current_zero = (offset << BitmapIndex::kStorageLogBitSize) + nth; + + size_t next_zero; + // Does the current block contain the next zero? + if (num_zeros_in_block > remzeros + 1) { + if (sum_zeros_next_word - sum_zeros_this_word >= remzeros + 1) { + // the next zero is in this word + next_zero = (offset << BitmapIndex::kStorageLogBitSize) + + nth_bit(~bits_[offset], remzeros + 1); + } else { + // Find the first field that is not all ones by linear scan. + // In the worst case, this may scan 8Kbytes. The alternative is + // to inspect secondary_index_ looking for a place to jump to, but + // that would probably use more cache. + while (bits_[++offset] == ones) { + } + next_zero = (offset << BitmapIndex::kStorageLogBitSize) + + __builtin_ctzll(~bits_[offset]); + } + } else { + // the next zero is in a different block, a full search is required. + next_zero = Select0(bit_index + 1); + } + return std::make_pair(current_zero, next_zero); +} + +size_t BitmapIndex::get_index_ones_count(size_t array_index) const { + uint32 sum = 0; + if (array_index > 0) { + sum += secondary_index_[array_index - 1]; + uint32 end_block = (array_index - 1) / kSecondaryBlockSize; + if (end_block > 0) sum += primary_index_[end_block - 1]; + } + return sum; +} + +void BitmapIndex::BuildIndex(const uint64 *bits, size_t size) { + bits_ = bits; + size_ = size; + primary_index_.resize(primary_index_size()); + secondary_index_.resize(ArraySize()); + const uint64 zero = 0; + const uint64 ones = ~zero; + uint32 popcount = 0; + for (uint32 block = 0; block * kSecondaryBlockSize < ArraySize(); block++) { + uint32 block_popcount = 0; + uint32 block_begin = block * kSecondaryBlockSize; + uint32 block_end = block_begin + kSecondaryBlockSize; + if (block_end > ArraySize()) block_end = ArraySize(); + for (uint32 j = block_begin; j < block_end; ++j) { + uint64 mask = ones; + if (j == ArraySize() - 1) { + mask = ones >> (-size_ & BitmapIndex::kStorageBlockMask); + } + block_popcount += __builtin_popcountll(bits_[j] & mask); + secondary_index_[j] = block_popcount; + } + popcount += block_popcount; + primary_index_[block] = popcount; + } +} + +size_t BitmapIndex::find_secondary_block(size_t block_begin, + size_t rem_bit_index) const { + size_t block_end = block_begin + kSecondaryBlockSize; + if (block_end > ArraySize()) block_end = ArraySize(); + return std::distance( + secondary_index_.begin() + block_begin, + std::lower_bound(secondary_index_.begin() + block_begin, + secondary_index_.begin() + block_end, rem_bit_index)); +} + +size_t BitmapIndex::find_inverted_secondary_block(size_t block_begin, + size_t rem_bit_index) const { + size_t block_end = block_begin + kSecondaryBlockSize; + if (block_end > ArraySize()) block_end = ArraySize(); + return InvertedSearch(secondary_index_, + block_begin, block_end, + rem_bit_index) + - block_begin; +} + +inline size_t BitmapIndex::find_primary_block(size_t bit_index) const { + return std::distance( + primary_index_.begin(), + std::lower_bound(primary_index_.begin(), + primary_index_.begin() + primary_index_size(), + bit_index)); +} + +size_t BitmapIndex::find_inverted_primary_block(size_t bit_index) const { + return InvertedSearch( + primary_index_, 0, primary_index_.size(), bit_index); +} +} // end namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/ngram/ngram-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/ngram/ngram-fst.cc new file mode 100644 index 0000000000..15940eb0c8 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/ngram/ngram-fst.cc @@ -0,0 +1,16 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +#include + +#include +#include + +using fst::NGramFst; +using fst::StdArc; +using fst::LogArc; + +REGISTER_FST(NGramFst, StdArc); +REGISTER_FST(NGramFst, LogArc); diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/ngram/nthbit.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/ngram/nthbit.cc new file mode 100644 index 0000000000..ac446e5108 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/ngram/nthbit.cc @@ -0,0 +1,72 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +// This table is generated using: +// +// unsigned int nth_bit_scan(uint64 v, unsigned int r) { +// int i=0; +// for (; i<64; i++) { +// if ((r -= v & 1) == 0) return i; +// v >>= 1; +// } +// return i; +// } +// +// for (size_t i = 0; i < 256; ++i) { +// uint32 offsets = 0; +// for (size_t b = 1; b <= 8; ++b) { +// uint32 offset = min(nth_bit_scan(i, b), 8); +// offsets |= (offset << ((b - 1) << 2)); +// } +// bit_offset = offsets; +// printf("0x%x, ", bit_offset); +// if (i % 4 == 3) printf("\n"); +// } +// +uint32 nth_bit_bit_offset[] = { + 0x88888888, 0x88888880, 0x88888881, 0x88888810, 0x88888882, 0x88888820, + 0x88888821, 0x88888210, 0x88888883, 0x88888830, 0x88888831, 0x88888310, + 0x88888832, 0x88888320, 0x88888321, 0x88883210, 0x88888884, 0x88888840, + 0x88888841, 0x88888410, 0x88888842, 0x88888420, 0x88888421, 0x88884210, + 0x88888843, 0x88888430, 0x88888431, 0x88884310, 0x88888432, 0x88884320, + 0x88884321, 0x88843210, 0x88888885, 0x88888850, 0x88888851, 0x88888510, + 0x88888852, 0x88888520, 0x88888521, 0x88885210, 0x88888853, 0x88888530, + 0x88888531, 0x88885310, 0x88888532, 0x88885320, 0x88885321, 0x88853210, + 0x88888854, 0x88888540, 0x88888541, 0x88885410, 0x88888542, 0x88885420, + 0x88885421, 0x88854210, 0x88888543, 0x88885430, 0x88885431, 0x88854310, + 0x88885432, 0x88854320, 0x88854321, 0x88543210, 0x88888886, 0x88888860, + 0x88888861, 0x88888610, 0x88888862, 0x88888620, 0x88888621, 0x88886210, + 0x88888863, 0x88888630, 0x88888631, 0x88886310, 0x88888632, 0x88886320, + 0x88886321, 0x88863210, 0x88888864, 0x88888640, 0x88888641, 0x88886410, + 0x88888642, 0x88886420, 0x88886421, 0x88864210, 0x88888643, 0x88886430, + 0x88886431, 0x88864310, 0x88886432, 0x88864320, 0x88864321, 0x88643210, + 0x88888865, 0x88888650, 0x88888651, 0x88886510, 0x88888652, 0x88886520, + 0x88886521, 0x88865210, 0x88888653, 0x88886530, 0x88886531, 0x88865310, + 0x88886532, 0x88865320, 0x88865321, 0x88653210, 0x88888654, 0x88886540, + 0x88886541, 0x88865410, 0x88886542, 0x88865420, 0x88865421, 0x88654210, + 0x88886543, 0x88865430, 0x88865431, 0x88654310, 0x88865432, 0x88654320, + 0x88654321, 0x86543210, 0x88888887, 0x88888870, 0x88888871, 0x88888710, + 0x88888872, 0x88888720, 0x88888721, 0x88887210, 0x88888873, 0x88888730, + 0x88888731, 0x88887310, 0x88888732, 0x88887320, 0x88887321, 0x88873210, + 0x88888874, 0x88888740, 0x88888741, 0x88887410, 0x88888742, 0x88887420, + 0x88887421, 0x88874210, 0x88888743, 0x88887430, 0x88887431, 0x88874310, + 0x88887432, 0x88874320, 0x88874321, 0x88743210, 0x88888875, 0x88888750, + 0x88888751, 0x88887510, 0x88888752, 0x88887520, 0x88887521, 0x88875210, + 0x88888753, 0x88887530, 0x88887531, 0x88875310, 0x88887532, 0x88875320, + 0x88875321, 0x88753210, 0x88888754, 0x88887540, 0x88887541, 0x88875410, + 0x88887542, 0x88875420, 0x88875421, 0x88754210, 0x88887543, 0x88875430, + 0x88875431, 0x88754310, 0x88875432, 0x88754320, 0x88754321, 0x87543210, + 0x88888876, 0x88888760, 0x88888761, 0x88887610, 0x88888762, 0x88887620, + 0x88887621, 0x88876210, 0x88888763, 0x88887630, 0x88887631, 0x88876310, + 0x88887632, 0x88876320, 0x88876321, 0x88763210, 0x88888764, 0x88887640, + 0x88887641, 0x88876410, 0x88887642, 0x88876420, 0x88876421, 0x88764210, + 0x88887643, 0x88876430, 0x88876431, 0x88764310, 0x88876432, 0x88764320, + 0x88764321, 0x87643210, 0x88888765, 0x88887650, 0x88887651, 0x88876510, + 0x88887652, 0x88876520, 0x88876521, 0x88765210, 0x88887653, 0x88876530, + 0x88876531, 0x88765310, 0x88876532, 0x88765320, 0x88765321, 0x87653210, + 0x88887654, 0x88876540, 0x88876541, 0x88765410, 0x88876542, 0x88765420, + 0x88765421, 0x87654210, 0x88876543, 0x88765430, 0x88765431, 0x87654310, + 0x88765432, 0x87654320, 0x87654321, 0x76543210, +}; diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/Makefile.am b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/Makefile.am new file mode 100644 index 0000000000..39cc70e9c5 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/Makefile.am @@ -0,0 +1,30 @@ +AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) + +if HAVE_BIN +bin_PROGRAMS = pdtcompose pdtexpand pdtinfo pdtreplace pdtreverse \ + pdtshortestpath + +LDADD = libfstpdtscript.la \ + ../../script/libfstscript.la \ + ../../lib/libfst.la -lm $(DL_LIBS) + +pdtcompose_SOURCES = pdtcompose.cc + +pdtexpand_SOURCES = pdtexpand.cc + +pdtinfo_SOURCES = pdtinfo.cc + +pdtreplace_SOURCES = pdtreplace.cc + +pdtreverse_SOURCES = pdtreverse.cc + +pdtshortestpath_SOURCES = pdtshortestpath.cc +endif + +if HAVE_SCRIPT +lib_LTLIBRARIES = libfstpdtscript.la +libfstpdtscript_la_SOURCES = getters.cc pdtscript.cc +libfstpdtscript_la_LDFLAGS = -version-info 10:0:0 +libfstpdtscript_la_LIBADD = ../../script/libfstscript.la \ + ../../lib/libfst.la -lm $(DL_LIBS) +endif diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/Makefile.in b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/Makefile.in new file mode 100644 index 0000000000..c082f01f3e --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/Makefile.in @@ -0,0 +1,812 @@ +# Makefile.in generated by automake 1.14.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2013 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + + +VPATH = @srcdir@ +am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +@HAVE_BIN_TRUE@bin_PROGRAMS = pdtcompose$(EXEEXT) pdtexpand$(EXEEXT) \ +@HAVE_BIN_TRUE@ pdtinfo$(EXEEXT) pdtreplace$(EXEEXT) \ +@HAVE_BIN_TRUE@ pdtreverse$(EXEEXT) pdtshortestpath$(EXEEXT) +subdir = src/extensions/pdt +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ + $(top_srcdir)/depcomp +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \ + $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ + $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ + $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h \ + $(top_builddir)/src/include/fst/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__uninstall_files_from_dir = { \ + test -z "$$files" \ + || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && rm -f $$files; }; \ + } +am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(bindir)" +LTLIBRARIES = $(lib_LTLIBRARIES) +am__DEPENDENCIES_1 = +@HAVE_SCRIPT_TRUE@libfstpdtscript_la_DEPENDENCIES = \ +@HAVE_SCRIPT_TRUE@ ../../script/libfstscript.la \ +@HAVE_SCRIPT_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +am__libfstpdtscript_la_SOURCES_DIST = getters.cc pdtscript.cc +@HAVE_SCRIPT_TRUE@am_libfstpdtscript_la_OBJECTS = getters.lo \ +@HAVE_SCRIPT_TRUE@ pdtscript.lo +libfstpdtscript_la_OBJECTS = $(am_libfstpdtscript_la_OBJECTS) +AM_V_lt = $(am__v_lt_@AM_V@) +am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) +am__v_lt_0 = --silent +am__v_lt_1 = +libfstpdtscript_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) $(libfstpdtscript_la_LDFLAGS) \ + $(LDFLAGS) -o $@ +@HAVE_SCRIPT_TRUE@am_libfstpdtscript_la_rpath = -rpath $(libdir) +PROGRAMS = $(bin_PROGRAMS) +am__pdtcompose_SOURCES_DIST = pdtcompose.cc +@HAVE_BIN_TRUE@am_pdtcompose_OBJECTS = pdtcompose.$(OBJEXT) +pdtcompose_OBJECTS = $(am_pdtcompose_OBJECTS) +pdtcompose_LDADD = $(LDADD) +@HAVE_BIN_TRUE@pdtcompose_DEPENDENCIES = libfstpdtscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +am__pdtexpand_SOURCES_DIST = pdtexpand.cc +@HAVE_BIN_TRUE@am_pdtexpand_OBJECTS = pdtexpand.$(OBJEXT) +pdtexpand_OBJECTS = $(am_pdtexpand_OBJECTS) +pdtexpand_LDADD = $(LDADD) +@HAVE_BIN_TRUE@pdtexpand_DEPENDENCIES = libfstpdtscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +am__pdtinfo_SOURCES_DIST = pdtinfo.cc +@HAVE_BIN_TRUE@am_pdtinfo_OBJECTS = pdtinfo.$(OBJEXT) +pdtinfo_OBJECTS = $(am_pdtinfo_OBJECTS) +pdtinfo_LDADD = $(LDADD) +@HAVE_BIN_TRUE@pdtinfo_DEPENDENCIES = libfstpdtscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +am__pdtreplace_SOURCES_DIST = pdtreplace.cc +@HAVE_BIN_TRUE@am_pdtreplace_OBJECTS = pdtreplace.$(OBJEXT) +pdtreplace_OBJECTS = $(am_pdtreplace_OBJECTS) +pdtreplace_LDADD = $(LDADD) +@HAVE_BIN_TRUE@pdtreplace_DEPENDENCIES = libfstpdtscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +am__pdtreverse_SOURCES_DIST = pdtreverse.cc +@HAVE_BIN_TRUE@am_pdtreverse_OBJECTS = pdtreverse.$(OBJEXT) +pdtreverse_OBJECTS = $(am_pdtreverse_OBJECTS) +pdtreverse_LDADD = $(LDADD) +@HAVE_BIN_TRUE@pdtreverse_DEPENDENCIES = libfstpdtscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +am__pdtshortestpath_SOURCES_DIST = pdtshortestpath.cc +@HAVE_BIN_TRUE@am_pdtshortestpath_OBJECTS = pdtshortestpath.$(OBJEXT) +pdtshortestpath_OBJECTS = $(am_pdtshortestpath_OBJECTS) +pdtshortestpath_LDADD = $(LDADD) +@HAVE_BIN_TRUE@pdtshortestpath_DEPENDENCIES = libfstpdtscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +DEFAULT_INCLUDES = +depcomp = $(SHELL) $(top_srcdir)/depcomp +am__depfiles_maybe = depfiles +am__mv = mv -f +CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CXXFLAGS) $(CXXFLAGS) +AM_V_CXX = $(am__v_CXX_@AM_V@) +am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@) +am__v_CXX_0 = @echo " CXX " $@; +am__v_CXX_1 = +CXXLD = $(CXX) +CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_CXXLD = $(am__v_CXXLD_@AM_V@) +am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@) +am__v_CXXLD_0 = @echo " CXXLD " $@; +am__v_CXXLD_1 = +SOURCES = $(libfstpdtscript_la_SOURCES) $(pdtcompose_SOURCES) \ + $(pdtexpand_SOURCES) $(pdtinfo_SOURCES) $(pdtreplace_SOURCES) \ + $(pdtreverse_SOURCES) $(pdtshortestpath_SOURCES) +DIST_SOURCES = $(am__libfstpdtscript_la_SOURCES_DIST) \ + $(am__pdtcompose_SOURCES_DIST) $(am__pdtexpand_SOURCES_DIST) \ + $(am__pdtinfo_SOURCES_DIST) $(am__pdtreplace_SOURCES_DIST) \ + $(am__pdtreverse_SOURCES_DIST) \ + $(am__pdtshortestpath_SOURCES_DIST) +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DL_LIBS = @DL_LIBS@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PYTHON = @PYTHON@ +PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@ +PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ +PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@ +PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@ +PYTHON_LDFLAGS = @PYTHON_LDFLAGS@ +PYTHON_PLATFORM = @PYTHON_PLATFORM@ +PYTHON_PREFIX = @PYTHON_PREFIX@ +PYTHON_SITE_PKG = @PYTHON_SITE_PKG@ +PYTHON_VERSION = @PYTHON_VERSION@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +libfstdir = @libfstdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgpyexecdir = @pkgpyexecdir@ +pkgpythondir = @pkgpythondir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +pyexecdir = @pyexecdir@ +pythondir = @pythondir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) +@HAVE_BIN_TRUE@LDADD = libfstpdtscript.la \ +@HAVE_BIN_TRUE@ ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la -lm $(DL_LIBS) + +@HAVE_BIN_TRUE@pdtcompose_SOURCES = pdtcompose.cc +@HAVE_BIN_TRUE@pdtexpand_SOURCES = pdtexpand.cc +@HAVE_BIN_TRUE@pdtinfo_SOURCES = pdtinfo.cc +@HAVE_BIN_TRUE@pdtreplace_SOURCES = pdtreplace.cc +@HAVE_BIN_TRUE@pdtreverse_SOURCES = pdtreverse.cc +@HAVE_BIN_TRUE@pdtshortestpath_SOURCES = pdtshortestpath.cc +@HAVE_SCRIPT_TRUE@lib_LTLIBRARIES = libfstpdtscript.la +@HAVE_SCRIPT_TRUE@libfstpdtscript_la_SOURCES = getters.cc pdtscript.cc +@HAVE_SCRIPT_TRUE@libfstpdtscript_la_LDFLAGS = -version-info 10:0:0 +@HAVE_SCRIPT_TRUE@libfstpdtscript_la_LIBADD = ../../script/libfstscript.la \ +@HAVE_SCRIPT_TRUE@ ../../lib/libfst.la -lm $(DL_LIBS) + +all: all-am + +.SUFFIXES: +.SUFFIXES: .cc .lo .o .obj +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/pdt/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign src/extensions/pdt/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +install-libLTLIBRARIES: $(lib_LTLIBRARIES) + @$(NORMAL_INSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \ + } + +uninstall-libLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \ + done + +clean-libLTLIBRARIES: + -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES) + @list='$(lib_LTLIBRARIES)'; \ + locs=`for p in $$list; do echo $$p; done | \ + sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ + sort -u`; \ + test -z "$$locs" || { \ + echo rm -f $${locs}; \ + rm -f $${locs}; \ + } + +libfstpdtscript.la: $(libfstpdtscript_la_OBJECTS) $(libfstpdtscript_la_DEPENDENCIES) $(EXTRA_libfstpdtscript_la_DEPENDENCIES) + $(AM_V_CXXLD)$(libfstpdtscript_la_LINK) $(am_libfstpdtscript_la_rpath) $(libfstpdtscript_la_OBJECTS) $(libfstpdtscript_la_LIBADD) $(LIBS) +install-binPROGRAMS: $(bin_PROGRAMS) + @$(NORMAL_INSTALL) + @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \ + if test -n "$$list"; then \ + echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \ + fi; \ + for p in $$list; do echo "$$p $$p"; done | \ + sed 's/$(EXEEXT)$$//' | \ + while read p p1; do if test -f $$p \ + || test -f $$p1 \ + ; then echo "$$p"; echo "$$p"; else :; fi; \ + done | \ + sed -e 'p;s,.*/,,;n;h' \ + -e 's|.*|.|' \ + -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \ + sed 'N;N;N;s,\n, ,g' | \ + $(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \ + { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \ + if ($$2 == $$4) files[d] = files[d] " " $$1; \ + else { print "f", $$3 "/" $$4, $$1; } } \ + END { for (d in files) print "f", d, files[d] }' | \ + while read type dir files; do \ + if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \ + test -z "$$files" || { \ + echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \ + $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \ + } \ + ; done + +uninstall-binPROGRAMS: + @$(NORMAL_UNINSTALL) + @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \ + files=`for p in $$list; do echo "$$p"; done | \ + sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \ + -e 's/$$/$(EXEEXT)/' \ + `; \ + test -n "$$list" || exit 0; \ + echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(bindir)" && rm -f $$files + +clean-binPROGRAMS: + @list='$(bin_PROGRAMS)'; test -n "$$list" || exit 0; \ + echo " rm -f" $$list; \ + rm -f $$list || exit $$?; \ + test -n "$(EXEEXT)" || exit 0; \ + list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \ + echo " rm -f" $$list; \ + rm -f $$list + +pdtcompose$(EXEEXT): $(pdtcompose_OBJECTS) $(pdtcompose_DEPENDENCIES) $(EXTRA_pdtcompose_DEPENDENCIES) + @rm -f pdtcompose$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(pdtcompose_OBJECTS) $(pdtcompose_LDADD) $(LIBS) + +pdtexpand$(EXEEXT): $(pdtexpand_OBJECTS) $(pdtexpand_DEPENDENCIES) $(EXTRA_pdtexpand_DEPENDENCIES) + @rm -f pdtexpand$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(pdtexpand_OBJECTS) $(pdtexpand_LDADD) $(LIBS) + +pdtinfo$(EXEEXT): $(pdtinfo_OBJECTS) $(pdtinfo_DEPENDENCIES) $(EXTRA_pdtinfo_DEPENDENCIES) + @rm -f pdtinfo$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(pdtinfo_OBJECTS) $(pdtinfo_LDADD) $(LIBS) + +pdtreplace$(EXEEXT): $(pdtreplace_OBJECTS) $(pdtreplace_DEPENDENCIES) $(EXTRA_pdtreplace_DEPENDENCIES) + @rm -f pdtreplace$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(pdtreplace_OBJECTS) $(pdtreplace_LDADD) $(LIBS) + +pdtreverse$(EXEEXT): $(pdtreverse_OBJECTS) $(pdtreverse_DEPENDENCIES) $(EXTRA_pdtreverse_DEPENDENCIES) + @rm -f pdtreverse$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(pdtreverse_OBJECTS) $(pdtreverse_LDADD) $(LIBS) + +pdtshortestpath$(EXEEXT): $(pdtshortestpath_OBJECTS) $(pdtshortestpath_DEPENDENCIES) $(EXTRA_pdtshortestpath_DEPENDENCIES) + @rm -f pdtshortestpath$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(pdtshortestpath_OBJECTS) $(pdtshortestpath_LDADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/getters.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtcompose.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtexpand.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtinfo.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtreplace.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtreverse.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtscript.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtshortestpath.Po@am__quote@ + +.cc.o: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $< + +.cc.obj: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cc.lo: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ +@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $< + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-am +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-am + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscopelist: cscopelist-am + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(LTLIBRARIES) $(PROGRAMS) +install-binPROGRAMS: install-libLTLIBRARIES + +installdirs: + for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(bindir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \ + clean-libtool mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: install-binPROGRAMS install-libLTLIBRARIES + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-binPROGRAMS uninstall-libLTLIBRARIES + +.MAKE: install-am install-strip + +.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \ + clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \ + clean-libtool cscopelist-am ctags ctags-am distclean \ + distclean-compile distclean-generic distclean-libtool \ + distclean-tags distdir dvi dvi-am html html-am info info-am \ + install install-am install-binPROGRAMS install-data \ + install-data-am install-dvi install-dvi-am install-exec \ + install-exec-am install-html install-html-am install-info \ + install-info-am install-libLTLIBRARIES install-man install-pdf \ + install-pdf-am install-ps install-ps-am install-strip \ + installcheck installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-compile \ + mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ + tags tags-am uninstall uninstall-am uninstall-binPROGRAMS \ + uninstall-libLTLIBRARIES + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/getters.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/getters.cc new file mode 100644 index 0000000000..e1c6877b47 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/getters.cc @@ -0,0 +1,34 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +namespace fst { +namespace script { + +bool GetPdtComposeFilter(const string &str, PdtComposeFilter *cf) { + if (str == "expand") { + *cf = EXPAND_FILTER; + } else if (str == "expand_paren") { + *cf = EXPAND_PAREN_FILTER; + } else if (str == "paren") { + *cf = PAREN_FILTER; + } else { + return false; + } + return true; +} + +bool GetPdtParserType(const string &str, PdtParserType *pt) { + if (str == "left") { + *pt = PDT_LEFT_PARSER; + } else if (str == "left_sr") { + *pt = PDT_LEFT_SR_PARSER; + } else { + return false; + } + return true; +} + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/pdtcompose.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/pdtcompose.cc new file mode 100644 index 0000000000..a6cdb38d5c --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/pdtcompose.cc @@ -0,0 +1,84 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Composes a PDT and an FST. + +#include + +#include +#include +#include + +#include +#include + +#include +#include +#include + +DEFINE_string(pdt_parentheses, "", "PDT parenthesis label pairs"); +DEFINE_bool(left_pdt, true, "Is the first argument the PDT?"); +DEFINE_bool(connect, true, "Trim output?"); +DEFINE_string(compose_filter, "paren", + "Composition filter, one of: \"expand\", \"expand_paren\", " + "\"paren\""); + +int main(int argc, char **argv) { + namespace s = fst::script; + using fst::ReadLabelPairs; + using fst::PdtComposeFilter; + using fst::PdtComposeOptions; + using fst::script::FstClass; + using fst::script::VectorFstClass; + + string usage = "Compose a PDT and an FST.\n\n Usage: "; + usage += argv[0]; + usage += " in.pdt in.fst [out.pdt]\n"; + usage += " in.fst in.pdt [out.pdt]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc < 3 || argc > 4) { + ShowUsage(); + return 1; + } + + const string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1]; + const string in2_name = strcmp(argv[2], "-") == 0 ? "" : argv[2]; + const string out_name = argc > 3 ? argv[3] : ""; + + if (in1_name.empty() && in2_name.empty()) { + LOG(ERROR) << argv[0] << ": Can't take both inputs from standard input."; + return 1; + } + + std::unique_ptr ifst1(FstClass::Read(in1_name)); + if (!ifst1) return 1; + std::unique_ptr ifst2(FstClass::Read(in2_name)); + if (!ifst2) return 1; + + if (FLAGS_pdt_parentheses.empty()) { + LOG(ERROR) << argv[0] << ": No PDT parenthesis label pairs provided"; + return 1; + } + + std::vector parens; + if (!ReadLabelPairs(FLAGS_pdt_parentheses, &parens, false)) return 1; + + VectorFstClass ofst(ifst1->ArcType()); + + PdtComposeFilter compose_filter; + if (!s::GetPdtComposeFilter(FLAGS_compose_filter, &compose_filter)) { + LOG(ERROR) << argv[0] << ": Unknown or unsupported compose filter type: " + << FLAGS_compose_filter; + return 1; + } + + const PdtComposeOptions copts(FLAGS_connect, compose_filter); + + s::PdtCompose(*ifst1, *ifst2, parens, &ofst, copts, FLAGS_left_pdt); + + ofst.Write(out_name); + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/pdtexpand.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/pdtexpand.cc new file mode 100644 index 0000000000..f605dc8049 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/pdtexpand.cc @@ -0,0 +1,68 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Expands a (bounded-stack) PDT as an FST. + +#include + +#include +#include +#include + +#include +#include + +#include +#include + +DEFINE_string(pdt_parentheses, "", "PDT parenthesis label pairs"); +DEFINE_bool(connect, true, "Trim output?"); +DEFINE_bool(keep_parentheses, false, "Keep PDT parentheses in result?"); +DEFINE_string(weight, "", "Weight threshold"); + +int main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + using fst::script::VectorFstClass; + using fst::script::WeightClass; + using fst::ReadLabelPairs; + + string usage = "Expand a (bounded-stack) PDT as an FST.\n\n Usage: "; + usage += argv[0]; + usage += " in.pdt [out.fst]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = + (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr ifst(FstClass::Read(in_name)); + if (!ifst) return 1; + + if (FLAGS_pdt_parentheses.empty()) { + LOG(ERROR) << argv[0] << ": No PDT parenthesis label pairs provided"; + return 1; + } + + std::vector parens; + if (!ReadLabelPairs(FLAGS_pdt_parentheses, &parens, false)) return 1; + + const auto weight_threshold = + FLAGS_weight.empty() ? WeightClass::Zero(ifst->WeightType()) + : WeightClass(ifst->WeightType(), FLAGS_weight); + + VectorFstClass ofst(ifst->ArcType()); + s::PdtExpand(*ifst, parens, &ofst, + s::PdtExpandOptions(FLAGS_connect, FLAGS_keep_parentheses, + weight_threshold)); + + ofst.Write(out_name); + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/pdtinfo.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/pdtinfo.cc new file mode 100644 index 0000000000..ca32150de1 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/pdtinfo.cc @@ -0,0 +1,54 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Prints out various information about a PDT such as number of states, arcs, +// and parentheses. + +#include + +#include +#include +#include + +#include +#include + +#include +#include + +DEFINE_string(pdt_parentheses, "", "PDT parenthesis label pairs"); + +int main(int argc, char **argv) { + namespace s = fst::script; + using fst::ReadLabelPairs; + using fst::script::FstClass; + + string usage = "Prints out information about a PDT.\n\n Usage: "; + usage += argv[0]; + usage += " in.pdt\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 2) { + ShowUsage(); + return 1; + } + + const string in_name = + (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : ""; + + std::unique_ptr ifst(FstClass::Read(in_name)); + if (!ifst) return 1; + + if (FLAGS_pdt_parentheses.empty()) { + LOG(ERROR) << argv[0] << ": No PDT parenthesis label pairs provided"; + return 1; + } + + std::vector parens; + if (!ReadLabelPairs(FLAGS_pdt_parentheses, &parens, false)) return 1; + + s::PrintPdtInfo(*ifst, parens); + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/pdtreplace.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/pdtreplace.cc new file mode 100644 index 0000000000..7a5f47d7c9 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/pdtreplace.cc @@ -0,0 +1,102 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Converts an RTN represented by FSTs and non-terminal labels into a PDT. + +#include + +#include +#include + +#include + +#include +#include +#include +#include + +DEFINE_string(pdt_parentheses, "", "PDT parenthesis label pairs"); +DEFINE_string(pdt_parser_type, "left", + "Construction method, one of: \"left\", \"left_sr\""); +DEFINE_int64(start_paren_labels, fst::kNoLabel, + "Index to use for the first inserted parentheses; if not " + "specified, the next available label beyond the highest output " + "label is used"); +DEFINE_string(left_paren_prefix, "(_", "Prefix to attach to SymbolTable " + "labels for inserted left parentheses"); +DEFINE_string(right_paren_prefix, ")_", "Prefix to attach to SymbolTable " + "labels for inserted right parentheses"); + +void Cleanup(std::vector *pairs) { + for (const auto &pair : *pairs) { + delete pair.second; + } + pairs->clear(); +} + +int main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + using fst::script::VectorFstClass; + using fst::PdtParserType; + using fst::WriteLabelPairs; + + string usage = "Converts an RTN represented by FSTs"; + usage += " and non-terminal labels into PDT.\n\n Usage: "; + usage += argv[0]; + usage += " root.fst rootlabel [rule1.fst label1 ...] [out.fst]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc < 4) { + ShowUsage(); + return 1; + } + + const string in_name = argv[1]; + const string out_name = argc % 2 == 0 ? argv[argc - 1] : ""; + + auto *ifst = FstClass::Read(in_name); + if (!ifst) return 1; + + PdtParserType parser_type; + if (!s::GetPdtParserType(FLAGS_pdt_parser_type, &parser_type)) { + LOG(ERROR) << argv[0] << ": Unknown PDT parser type: " + << FLAGS_pdt_parser_type; + delete ifst; + return 1; + } + + std::vector pairs; + // Note that if the root label is beyond the range of the underlying FST's + // labels, truncation will occur. + const auto root = atoll(argv[2]); + pairs.emplace_back(root, ifst); + + for (auto i = 3; i < argc - 1; i += 2) { + ifst = FstClass::Read(argv[i]); + if (!ifst) { + Cleanup(&pairs); + return 1; + } + // Note that if the root label is beyond the range of the underlying FST's + // labels, truncation will occur. + const auto label = atoll(argv[i + 1]); + pairs.emplace_back(label, ifst); + } + + VectorFstClass ofst(ifst->ArcType()); + std::vector parens; + s::PdtReplace(pairs, &ofst, &parens, root, parser_type, + FLAGS_start_paren_labels, FLAGS_left_paren_prefix, + FLAGS_right_paren_prefix); + Cleanup(&pairs); + + if (!FLAGS_pdt_parentheses.empty()) { + if (!WriteLabelPairs(FLAGS_pdt_parentheses, parens)) return 1; + } + + ofst.Write(out_name); + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/pdtreverse.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/pdtreverse.cc new file mode 100644 index 0000000000..042f757117 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/pdtreverse.cc @@ -0,0 +1,59 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Reverses a PDT. + +#include + +#include +#include +#include + +#include +#include + +#include +#include + +DEFINE_string(pdt_parentheses, "", "PDT parenthesis label pairs"); + +int main(int argc, char **argv) { + namespace s = fst::script; + using fst::ReadLabelPairs; + using fst::script::FstClass; + using fst::script::VectorFstClass; + + string usage = "Reverse a PDT.\n\n Usage: "; + usage += argv[0]; + usage += " in.pdt [out.fst]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = + (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr ifst(FstClass::Read(in_name)); + if (!ifst) return 1; + + if (FLAGS_pdt_parentheses.empty()) { + LOG(ERROR) << argv[0] << ": No PDT parenthesis label pairs provided"; + return 1; + } + + std::vector parens; + if (!ReadLabelPairs(FLAGS_pdt_parentheses, &parens, false)) return 1; + + VectorFstClass ofst(ifst->ArcType()); + + s::PdtReverse(*ifst, parens, &ofst); + + ofst.Write(out_name); + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/pdtscript.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/pdtscript.cc new file mode 100644 index 0000000000..64da24463d --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/pdtscript.cc @@ -0,0 +1,96 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Definitions of 'scriptable' versions of pdt operations, that is, +// those that can be called with FstClass-type arguments. +// +// See comments in nlp/fst/script/script-impl.h for how the registration +// mechanism allows these to work with various arc types. + +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +namespace fst { +namespace script { + +void PdtCompose(const FstClass &ifst1, const FstClass &ifst2, + const std::vector &parens, + MutableFstClass *ofst, const PdtComposeOptions &copts, + bool left_pdt) { + if (!internal::ArcTypesMatch(ifst1, ifst2, "PdtCompose") || + !internal::ArcTypesMatch(ifst1, *ofst, "PdtCompose")) + return; + PdtComposeArgs args(ifst1, ifst2, parens, ofst, copts, left_pdt); + Apply>("PdtCompose", ifst1.ArcType(), &args); +} + +void PdtExpand(const FstClass &ifst, + const std::vector &parens, + MutableFstClass *ofst, const PdtExpandOptions &opts) { + PdtExpandArgs args(ifst, parens, ofst, opts); + Apply>("PdtExpand", ifst.ArcType(), &args); +} + +void PdtExpand(const FstClass &ifst, + const std::vector> &parens, + MutableFstClass *ofst, bool connect, bool keep_parentheses, + const WeightClass &weight_threshold) { + PdtExpand(ifst, parens, ofst, + PdtExpandOptions(connect, keep_parentheses, weight_threshold)); +} + +void PdtReplace(const std::vector &pairs, + MutableFstClass *ofst, std::vector *parens, + int64 root, PdtParserType parser_type, int64 start_paren_labels, + const string &left_paren_prefix, + const string &right_paren_prefix) { + for (size_t i = 1; i < pairs.size(); ++i) { + if (!internal::ArcTypesMatch(*pairs[i - 1].second, *pairs[i].second, + "PdtReplace")) + return; + } + if (!internal::ArcTypesMatch(*pairs[0].second, *ofst, "PdtReplace")) return; + PdtReplaceArgs args(pairs, ofst, parens, root, parser_type, + start_paren_labels, left_paren_prefix, + right_paren_prefix); + Apply>("PdtReplace", ofst->ArcType(), &args); +} + +void PdtReverse(const FstClass &ifst, + const std::vector &parens, + MutableFstClass *ofst) { + PdtReverseArgs args(ifst, parens, ofst); + Apply>("PdtReverse", ifst.ArcType(), &args); +} + +void PdtShortestPath(const FstClass &ifst, + const std::vector &parens, + MutableFstClass *ofst, + const PdtShortestPathOptions &opts) { + PdtShortestPathArgs args(ifst, parens, ofst, opts); + Apply>("PdtShortestPath", ifst.ArcType(), + &args); +} + +void PrintPdtInfo(const FstClass &ifst, + const std::vector &parens) { + PrintPdtInfoArgs args(ifst, parens); + Apply>("PrintPdtInfo", ifst.ArcType(), &args); +} + +// Register operations for common arc types. + +REGISTER_FST_PDT_OPERATIONS(StdArc); +REGISTER_FST_PDT_OPERATIONS(LogArc); +REGISTER_FST_PDT_OPERATIONS(Log64Arc); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/pdtshortestpath.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/pdtshortestpath.cc new file mode 100644 index 0000000000..a7956b0157 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/pdt/pdtshortestpath.cc @@ -0,0 +1,80 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Returns the shortest path in a (bounded-stack) PDT. + +#include + +#include +#include +#include + +#include +#include + +#include +#include + +DEFINE_bool(keep_parentheses, false, "Keep PDT parentheses in result?"); +DEFINE_string(queue_type, "fifo", + "Queue type: one of: " + "\"fifo\", \"lifo\", \"state\""); +DEFINE_bool(path_gc, true, "Garbage collect shortest path data?"); +DEFINE_string(pdt_parentheses, "", "PDT parenthesis label pairs"); + +int main(int argc, char **argv) { + namespace s = fst::script; + using fst::script::FstClass; + using fst::script::VectorFstClass; + using fst::QueueType; + using fst::ReadLabelPairs; + + string usage = "Shortest path in a (bounded-stack) PDT.\n\n Usage: "; + usage += argv[0]; + usage += " in.pdt [out.fst]\n"; + + std::set_new_handler(FailedNewHandler); + SET_FLAGS(usage.c_str(), &argc, &argv, true); + if (argc > 3) { + ShowUsage(); + return 1; + } + + const string in_name = + (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : ""; + const string out_name = argc > 2 ? argv[2] : ""; + + std::unique_ptr ifst(FstClass::Read(in_name)); + if (!ifst) return 1; + + if (FLAGS_pdt_parentheses.empty()) { + LOG(ERROR) << argv[0] << ": No PDT parenthesis label pairs provided"; + return 1; + } + + std::vector parens; + if (!ReadLabelPairs(FLAGS_pdt_parentheses, &parens, false)) return 1; + + VectorFstClass ofst(ifst->ArcType()); + + QueueType qt; + if (FLAGS_queue_type == "fifo") { + qt = fst::FIFO_QUEUE; + } else if (FLAGS_queue_type == "lifo") { + qt = fst::LIFO_QUEUE; + } else if (FLAGS_queue_type == "state") { + qt = fst::STATE_ORDER_QUEUE; + } else { + LOG(ERROR) << "Unknown queue type: " << FLAGS_queue_type; + return 1; + } + + const s::PdtShortestPathOptions opts(qt, FLAGS_keep_parentheses, + FLAGS_path_gc); + + s::PdtShortestPath(*ifst, parens, &ofst, opts); + + ofst.Write(out_name); + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/Makefile.am b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/Makefile.am new file mode 100644 index 0000000000..3406524311 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/Makefile.am @@ -0,0 +1,18 @@ +# NB: we use the Cython-generated .cc files rather than the *.pxd/.pyx sources +# used to generate them. Consequently, modifications to the .pyx files will not +# influence the build unless the .cc files are regenerated using Cython. + +python_LTLIBRARIES = pywrapfst.la + +pyexec_LTILIBRARIES = pywrapfst.la + +pywrapfst_la_SOURCES = pywrapfst.cc +pywrapfst_la_CPPFLAGS = -I$(srcdir)/../../include $(PYTHON_CPPFLAGS) +pywrapfst_la_LDFLAGS = $(PYTHON_LDFLAGS) -avoid-version -module +pywrapfst_la_LIBADD = ../far/libfstfarscript.la ../far/libfstfar.la \ + ../../script/libfstscript.la ../../lib/libfst.la \ + -lm $(DL_LIBS) + +# Exports the *.pxd/*.pxd source files. +EXTRA_DIST = basictypes.pxd fst.pxd ios.pxd memory.pxd pywrapfst.pxd \ + pywrapfst.pyx diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/Makefile.in b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/Makefile.in new file mode 100644 index 0000000000..2f35978aa8 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/Makefile.in @@ -0,0 +1,680 @@ +# Makefile.in generated by automake 1.14.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2013 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +# NB: we use the Cython-generated .cc files rather than the *.pxd/.pyx sources +# used to generate them. Consequently, modifications to the .pyx files will not +# influence the build unless the .cc files are regenerated using Cython. + +VPATH = @srcdir@ +am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +subdir = src/extensions/python +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ + $(top_srcdir)/depcomp +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \ + $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ + $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ + $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h \ + $(top_builddir)/src/include/fst/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__uninstall_files_from_dir = { \ + test -z "$$files" \ + || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && rm -f $$files; }; \ + } +am__installdirs = "$(DESTDIR)$(pythondir)" +LTLIBRARIES = $(python_LTLIBRARIES) +am__DEPENDENCIES_1 = +pywrapfst_la_DEPENDENCIES = ../far/libfstfarscript.la \ + ../far/libfstfar.la ../../script/libfstscript.la \ + ../../lib/libfst.la $(am__DEPENDENCIES_1) +am_pywrapfst_la_OBJECTS = pywrapfst_la-pywrapfst.lo +pywrapfst_la_OBJECTS = $(am_pywrapfst_la_OBJECTS) +AM_V_lt = $(am__v_lt_@AM_V@) +am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) +am__v_lt_0 = --silent +am__v_lt_1 = +pywrapfst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(pywrapfst_la_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +DEFAULT_INCLUDES = +depcomp = $(SHELL) $(top_srcdir)/depcomp +am__depfiles_maybe = depfiles +am__mv = mv -f +CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CXXFLAGS) $(CXXFLAGS) +AM_V_CXX = $(am__v_CXX_@AM_V@) +am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@) +am__v_CXX_0 = @echo " CXX " $@; +am__v_CXX_1 = +CXXLD = $(CXX) +CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_CXXLD = $(am__v_CXXLD_@AM_V@) +am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@) +am__v_CXXLD_0 = @echo " CXXLD " $@; +am__v_CXXLD_1 = +SOURCES = $(pywrapfst_la_SOURCES) +DIST_SOURCES = $(pywrapfst_la_SOURCES) +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DL_LIBS = @DL_LIBS@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PYTHON = @PYTHON@ +PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@ +PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ +PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@ +PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@ +PYTHON_LDFLAGS = @PYTHON_LDFLAGS@ +PYTHON_PLATFORM = @PYTHON_PLATFORM@ +PYTHON_PREFIX = @PYTHON_PREFIX@ +PYTHON_SITE_PKG = @PYTHON_SITE_PKG@ +PYTHON_VERSION = @PYTHON_VERSION@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +libfstdir = @libfstdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgpyexecdir = @pkgpyexecdir@ +pkgpythondir = @pkgpythondir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +pyexecdir = @pyexecdir@ +pythondir = @pythondir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +python_LTLIBRARIES = pywrapfst.la +pyexec_LTILIBRARIES = pywrapfst.la +pywrapfst_la_SOURCES = pywrapfst.cc +pywrapfst_la_CPPFLAGS = -I$(srcdir)/../../include $(PYTHON_CPPFLAGS) +pywrapfst_la_LDFLAGS = $(PYTHON_LDFLAGS) -avoid-version -module +pywrapfst_la_LIBADD = ../far/libfstfarscript.la ../far/libfstfar.la \ + ../../script/libfstscript.la ../../lib/libfst.la \ + -lm $(DL_LIBS) + + +# Exports the *.pxd/*.pxd source files. +EXTRA_DIST = basictypes.pxd fst.pxd ios.pxd memory.pxd pywrapfst.pxd \ + pywrapfst.pyx + +all: all-am + +.SUFFIXES: +.SUFFIXES: .cc .lo .o .obj +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/python/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign src/extensions/python/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +install-pythonLTLIBRARIES: $(python_LTLIBRARIES) + @$(NORMAL_INSTALL) + @list='$(python_LTLIBRARIES)'; test -n "$(pythondir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(pythondir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(pythondir)" || exit 1; \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(pythondir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(pythondir)"; \ + } + +uninstall-pythonLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(python_LTLIBRARIES)'; test -n "$(pythondir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(pythondir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(pythondir)/$$f"; \ + done + +clean-pythonLTLIBRARIES: + -test -z "$(python_LTLIBRARIES)" || rm -f $(python_LTLIBRARIES) + @list='$(python_LTLIBRARIES)'; \ + locs=`for p in $$list; do echo $$p; done | \ + sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ + sort -u`; \ + test -z "$$locs" || { \ + echo rm -f $${locs}; \ + rm -f $${locs}; \ + } + +pywrapfst.la: $(pywrapfst_la_OBJECTS) $(pywrapfst_la_DEPENDENCIES) $(EXTRA_pywrapfst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(pywrapfst_la_LINK) -rpath $(pythondir) $(pywrapfst_la_OBJECTS) $(pywrapfst_la_LIBADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pywrapfst_la-pywrapfst.Plo@am__quote@ + +.cc.o: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $< + +.cc.obj: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cc.lo: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ +@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $< + +pywrapfst_la-pywrapfst.lo: pywrapfst.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(pywrapfst_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT pywrapfst_la-pywrapfst.lo -MD -MP -MF $(DEPDIR)/pywrapfst_la-pywrapfst.Tpo -c -o pywrapfst_la-pywrapfst.lo `test -f 'pywrapfst.cc' || echo '$(srcdir)/'`pywrapfst.cc +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/pywrapfst_la-pywrapfst.Tpo $(DEPDIR)/pywrapfst_la-pywrapfst.Plo +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='pywrapfst.cc' object='pywrapfst_la-pywrapfst.lo' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(pywrapfst_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o pywrapfst_la-pywrapfst.lo `test -f 'pywrapfst.cc' || echo '$(srcdir)/'`pywrapfst.cc + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-am +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-am + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscopelist: cscopelist-am + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(LTLIBRARIES) +installdirs: + for dir in "$(DESTDIR)$(pythondir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic clean-libtool clean-pythonLTLIBRARIES \ + mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: install-pythonLTLIBRARIES + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-pythonLTLIBRARIES + +.MAKE: install-am install-strip + +.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \ + clean-libtool clean-pythonLTLIBRARIES cscopelist-am ctags \ + ctags-am distclean distclean-compile distclean-generic \ + distclean-libtool distclean-tags distdir dvi dvi-am html \ + html-am info info-am install install-am install-data \ + install-data-am install-dvi install-dvi-am install-exec \ + install-exec-am install-html install-html-am install-info \ + install-info-am install-man install-pdf install-pdf-am \ + install-ps install-ps-am install-pythonLTLIBRARIES \ + install-strip installcheck installcheck-am installdirs \ + maintainer-clean maintainer-clean-generic mostlyclean \ + mostlyclean-compile mostlyclean-generic mostlyclean-libtool \ + pdf pdf-am ps ps-am tags tags-am uninstall uninstall-am \ + uninstall-pythonLTLIBRARIES + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/basictypes.pxd b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/basictypes.pxd new file mode 100644 index 0000000000..0d93677a0f --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/basictypes.pxd @@ -0,0 +1,17 @@ +# See www.openfst.org for extensive documentation on this weighted +# finite-state transducer library. + + +from libc.stdint cimport * + + +cdef extern from "" nogil: + + ctypedef int8_t int8 + ctypedef int16_t int16 + ctypedef int32_t int32 + ctypedef int64_t int64 + ctypedef uint8_t uint8 + ctypedef uint16_t uint16 + ctypedef uint32_t uint32 + ctypedef uint64_t uint64 diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/fst.pxd b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/fst.pxd new file mode 100644 index 0000000000..45c15c5187 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/fst.pxd @@ -0,0 +1,747 @@ +# See www.openfst.org for extensive documentation on this weighted +# finite-state transducer library. + + +from libc.time cimport time_t +from libc.time cimport time + +from libcpp cimport bool +from libcpp.vector cimport vector +from libcpp.utility cimport pair + +from libcpp.string cimport string +from basictypes cimport int32 +from basictypes cimport int64 +from basictypes cimport uint32 +from basictypes cimport uint64 +from ios cimport istream +from ios cimport ostream + + +cdef extern from "" nogil: + + # Note that this is a copy, so it should be viewed as read-only. + + bool FLAGS_fst_error_fatal + + +cdef extern from "" namespace "fst" nogil: + + # FST properties. + const uint64 kExpanded + const uint64 kMutable + const uint64 kError + const uint64 kAcceptor + const uint64 kNotAcceptor + const uint64 kIDeterministic + const uint64 kNonIDeterministic + const uint64 kODeterministic + const uint64 kNonODeterministic + const uint64 kEpsilons + const uint64 kNoEpsilons + const uint64 kIEpsilons + const uint64 kNoIEpsilons + const uint64 kOEpsilons + const uint64 kNoOEpsilons + const uint64 kILabelSorted + const uint64 kNotILabelSorted + const uint64 kOLabelSorted + const uint64 kNotOLabelSorted + const uint64 kWeighted + const uint64 kUnweighted + const uint64 kCyclic + const uint64 kAcyclic + const uint64 kInitialCyclic + const uint64 kInitialAcyclic + const uint64 kTopSorted + const uint64 kNotTopSorted + const uint64 kAccessible + const uint64 kNotAccessible + const uint64 kCoAccessible + const uint64 kNotCoAccessible + const uint64 kString + const uint64 kNotString + const uint64 kWeightedCycles + const uint64 kUnweightedCycles + const uint64 kNullProperties + const uint64 kCopyProperties + const uint64 kIntrinsicProperties + const uint64 kExtrinsicProperties + const uint64 kSetStartProperties + const uint64 kSetFinalProperties + const uint64 kAddStateProperties + const uint64 kAddArcProperties + const uint64 kSetArcProperties + const uint64 kDeleteStatesProperties + const uint64 kDeleteArcsProperties + const uint64 kStateSortProperties + const uint64 kArcSortProperties + const uint64 kILabelInvariantProperties + const uint64 kOLabelInvariantProperties + const uint64 kWeightInvariantProperties + const uint64 kAddSuperFinalProperties + const uint64 kRmSuperFinalProperties + const uint64 kBinaryProperties + const uint64 kTrinaryProperties + const uint64 kPosTrinaryProperties + const uint64 kNegTrinaryProperties + const uint64 kFstProperties + + # ArcIterator flags. + const uint32 kArcILabelValue + const uint32 kArcOLabelValue + const uint32 kArcWeightValue + const uint32 kArcNextStateValue + const uint32 kArcNoCache + const uint32 kArcValueFlags + const uint32 kArcFlags + + # EncodeMapper flags. + const uint32 kEncodeLabels + const uint32 kEncodeWeights + const uint32 kEncodeFlags + + # Default argument constants. + const float kDelta + const float kShortestDelta + const int kNoLabel + const int kNoStateId + const int64 kNoSymbol + + enum ClosureType: + CLOSURE_STAR + CLOSURE_PLUS + + + enum ComposeFilter: + AUTO_FILTER + NULL_FILTER + SEQUENCE_FILTER + ALT_SEQUENCE_FILTER + MATCH_FILTER + TRIVIAL_FILTER + + + cdef cppclass ComposeOptions: + + ComposeOptions(bool, ComposeFilter) + + + enum DeterminizeType: + DETERMINIZE_FUNCTIONAL + DETERMINIZE_NONFUNCTIONAL + DETERMINIZE_DISAMBIGUATE + + + enum EncodeType: + DECODE + ENCODE + + + enum EpsNormalizeType: + EPS_NORM_INPUT + EPS_NORM_OUTPUT + + + enum ProjectType: + PROJECT_INPUT + PROJECT_OUTPUT + + + enum QueueType: + TRIVIAL_QUEUE + FIFO_QUEUE + LIFO_QUEUE + SHORTEST_FIRST_QUEUE + TOP_ORDER_QUEUE + STATE_ORDER_QUEUE + SCC_QUEUE + AUTO_QUEUE + OTHER_QUEUE + + + # This is a templated struct at the C++ level, but Cython does not support + # templated structs unless we pretend they are full-blown classes. + cdef cppclass RandGenOptions[RandArcSelection]: + + RandGenOptions(const RandArcSelection &, int32, int32, bool, bool) + + + enum ReplaceLabelType: + REPLACE_LABEL_NEITHER + REPLACE_LABEL_INPUT + REPLACE_LABEL_OUTPUT + REPLACE_LABEL_BOTH + + + enum ReweightType: + REWEIGHT_TO_INITIAL + REWEIGHT_TO_FINAL + + + cdef cppclass SymbolTableTextOptions: + + SymbolTableTextOptions(bool) + + # Symbol tables. + cdef cppclass SymbolTable: + + SymbolTable() + + SymbolTable(const string &) + + @staticmethod + SymbolTable *Read(const string &) + + @staticmethod + SymbolTable *ReadText(const string &, const SymbolTableTextOptions &) + + int64 AddSymbol(const string &, int64) + + int64 AddSymbol(const string &) + + SymbolTable *Copy() + + # Aliased for overload. + string FindSymbol "Find"(int64) + + # Aliased for overload. + int64 FindIndex "Find"(string) + + # Aliased for overload. + bool MemberSymbol "Member"(string) + + # Aliased for overload. + bool MemberIndex "Member"(int64) + + void AddTable(const SymbolTable &) + + int64 GetNthKey(ssize_t) + + const string &Name() + + void SetName(const string &) + + const string &CheckSum() + + const string &LabeledCheckSum() + + bool Write(const string &) + + bool WriteText(const string &) + + int64 AvailableKey() + + size_t NumSymbols() + + + SymbolTable *CompactSymbolTable(const SymbolTable &syms) + + SymbolTable *MergeSymbolTable(const SymbolTable &, const SymbolTable &, + bool *) + + SymbolTable *FstReadSymbols(const string &, bool) + + + cdef cppclass SymbolTableIterator: + + SymbolTableIterator(const SymbolTable &) + + bool Done() + + void Next() + + void Reset() + + string Symbol() + + int64 Value() + + +cdef extern from "" namespace "fst::script" nogil: + + + # Weights. + cdef cppclass WeightClass: + + WeightClass() + + WeightClass(const WeightClass &) + + WeightClass(const string &, const string &) + + const string &Type() + + string ToString() + + @staticmethod + const WeightClass &Zero(const string &) + + @staticmethod + const WeightClass &One(const string &) + + @staticmethod + const WeightClass &NoWeight(const string &) + + # Alias. + cdef bool Eq "operator=="(const WeightClass &, const WeightClass &) + + # Alias. + cdef bool Ne "operator!="(const WeightClass &, const WeightClass &) + + cdef WeightClass Plus(const WeightClass &, const WeightClass &) + + cdef WeightClass Times(const WeightClass &, const WeightClass &) + + cdef WeightClass Divide(const WeightClass &, const WeightClass &) + + cdef WeightClass Power(const WeightClass &, size_t) + + # Arcs. + cdef cppclass ArcClass: + + ArcClass(const ArcClass &) + + ArcClass(int64, int64, const WeightClass &, int64) + + int64 ilabel + int64 olabel + WeightClass weight + int64 nextstate + + + # FSTs. + + + cdef cppclass FstClass: + + FstClass(const FstClass &) + + @staticmethod + FstClass *Read(const string &) + + # Aliased for overload. + @staticmethod + FstClass *ReadFromStream "Read"(istream &, const string &) + + int64 Start() + + WeightClass Final(int64) + + size_t NumArcs(int64) + + size_t NumInputEpsilons(int64) + + size_t NumOutputEpsilons(int64) + + const string &ArcType() + + const string &FstType() + + const SymbolTable *InputSymbols() + + const SymbolTable *OutputSymbols() + + const string &WeightType() + + bool Write(const string &) + + bool Write(ostream &, const string &) + + uint64 Properties(uint64, bool) + + bool ValidStateId(int64) + + + cdef cppclass MutableFstClass(FstClass): + + bool AddArc(int64, const ArcClass &) + + int64 AddState() + + bool DeleteArcs(int64, size_t) + + bool DeleteArcs(int64) + + bool DeleteStates(const vector[int64] &) + + void DeleteStates() + + SymbolTable *MutableInputSymbols() + + SymbolTable *MutableOutputSymbols() + + int64 NumStates() + + bool ReserveArcs(int64, size_t) + + void ReserveStates(int64) + + bool SetStart(int64) + + bool SetFinal(int64, const WeightClass &) + + void SetInputSymbols(SymbolTable *) + + void SetOutputSymbols(SymbolTable *) + + void SetProperties(uint64, uint64) + + cdef cppclass VectorFstClass(MutableFstClass): + + VectorFstClass(const FstClass &) + + VectorFstClass(const string &) + + + # EncodeMapper. + cdef cppclass EncodeMapperClass: + + EncodeMapperClass(const string &, uint32, EncodeType) + + # Aliased to __call__ as Cython doesn't have good support for operator(). + ArcClass __call__ "operator()"(const ArcClass &) + + const string &ArcType() + + uint32 Flags() + + uint64 Properties(uint64) + + EncodeType Type() + + const SymbolTable *InputSymbols() + + const SymbolTable *OutputSymbols() + + void SetInputSymbols(const SymbolTable *) + + void SetOutputSymbols(const SymbolTable *) + + const string &WeightType() + + + # Iterators. + + + cdef cppclass ArcIteratorClass: + + ArcIteratorClass(const FstClass &, int64) + + bool Done() + + ArcClass Value() + + void Next() + + void Reset() + + void Seek(size_t) + + size_t Position() + + uint32 Flags() + + void SetFlags(uint32, uint32) + + cdef cppclass MutableArcIteratorClass: + + MutableArcIteratorClass(MutableFstClass *, int64) + + bool Done() + + ArcClass Value() + + void Next() + + void Reset() + + void Seek(size_t) + + void SetValue(const ArcClass &) + + size_t Position() + + uint32 Flags() + + void SetFlags(uint32, uint32) + + cdef cppclass StateIteratorClass: + + StateIteratorClass(const FstClass &) + + bool Done() + + int64 Value() + + void Next() + + void Reset() + + +ctypedef pair[int64, const FstClass *] LabelFstClassPair + +ctypedef pair[int64, int64] LabelPair + + +cdef extern from "" namespace "fst::script" nogil: + + enum ArcFilterType: + ANY_ARC_FILTER + EPSILON_ARC_FILTER + INPUT_EPSILON_ARC_FILTER + OUTPUT_EPSILON_ARC_FILTER + + enum ArcSortType: + ILABEL_SORT + OLABEL_SORT + + cdef void ArcSort(MutableFstClass *, ArcSortType) + + cdef ClosureType GetClosureType(bool) + + cdef void Closure(MutableFstClass *, ClosureType) + + cdef FstClass *CompileFstInternal(istream &, const string &, + const string &, const string &, + const SymbolTable *, const SymbolTable *, + const SymbolTable*, bool, bool, bool, bool, + bool) + + cdef void Compose(FstClass &, FstClass &, MutableFstClass *, + const ComposeOptions &) + + cdef void Concat(MutableFstClass *, const FstClass &) + + cdef void Connect(MutableFstClass *) + + cdef FstClass *Convert(const FstClass &, const string &) + + cdef void Decode(MutableFstClass *, const EncodeMapperClass &) + + cdef cppclass DeterminizeOptions: + + DeterminizeOptions(float, const WeightClass &, int64, int64, + DeterminizeType, bool) + + cdef void Determinize(const FstClass &, MutableFstClass *, + const DeterminizeOptions &) + + cdef cppclass DisambiguateOptions: + + DisambiguateOptions(float, const WeightClass &, int64, int64) + + cdef void Disambiguate(const FstClass &, MutableFstClass *, + const DisambiguateOptions &) + + cdef void Difference(const FstClass &, const FstClass &, MutableFstClass *, + const ComposeOptions &) + + cdef void DrawFst(const FstClass &fst, const SymbolTable *, + const SymbolTable *, const SymbolTable *, bool, + const string &, float, float, bool, bool, float, float, int, + int, const string &, bool, ostream *, const string &) + + cdef void Encode(MutableFstClass *, EncodeMapperClass *) + + cdef EpsNormalizeType GetEpsNormalizeType(bool) + + cdef void EpsNormalize(const FstClass &, MutableFstClass *, EpsNormalizeType) + + cdef bool Equal(const FstClass &, const FstClass &, float) + + cdef bool Equivalent(const FstClass &, const FstClass &, float) + + cdef void Intersect(const FstClass &, const FstClass &, MutableFstClass *, + const ComposeOptions &) + + cdef void Invert(MutableFstClass *fst) + + cdef bool Isomorphic(const FstClass &, const FstClass &, float) + + enum MapType: + ARC_SUM_MAPPER + IDENTITY_MAPPER + INPUT_EPSILON_MAPPER + INVERT_MAPPER + OUTPUT_EPSILON_MAPPER + PLUS_MAPPER + QUANTIZE_MAPPER + RMWEIGHT_MAPPER + SUPERFINAL_MAPPER + TIMES_MAPPER + TO_LOG_MAPPER + TO_LOG64_MAPPER + TO_STD_MAPPER + + cdef FstClass *Map(const FstClass &, MapType, float, double, + const WeightClass &) + + cdef void Minimize(MutableFstClass *, MutableFstClass *, float, bool) + + cdef ProjectType GetProjectType(bool) + + cdef void Project(MutableFstClass *, ProjectType) + + cdef void PrintFst(const FstClass &, ostream &, const string &, + const SymbolTable *, const SymbolTable *, + const SymbolTable *, bool, bool, const string &) + + cdef void Prune(const FstClass &, MutableFstClass *, const WeightClass &, + int64, float) + + cdef void Prune(MutableFstClass *, const WeightClass &, int64, float) + + cdef void Push(const FstClass &, MutableFstClass *, uint32 flags, + ReweightType, float) + + cdef void Push(MutableFstClass *, ReweightType, float, bool) + + enum RandArcSelection: + UNIFORM_ARC_SELECTOR + LOG_PROB_ARC_SELECTOR + FAST_LOG_PROB_ARC_SELECTOR + + cdef bool RandEquivalent(const FstClass &, const FstClass &, int32, float, + time_t, const RandGenOptions[RandArcSelection] &) + + cdef void RandGen(const FstClass &, MutableFstClass *, time_t, + const RandGenOptions[RandArcSelection] &) + + cdef void Relabel(MutableFstClass *, const SymbolTable *, + const SymbolTable *, const string &, bool, + const SymbolTable *, const SymbolTable *, const string &, + bool) + + cdef void Relabel(MutableFstClass *, const vector[LabelPair] &, + const vector[LabelPair] &) + + cdef cppclass ReplaceOptions: + + ReplaceOptions(int64, ReplaceLabelType, ReplaceLabelType, int64) + + cdef void Replace(const vector[LabelFstClassPair] &, MutableFstClass *, + const ReplaceOptions &) + + cdef void Reverse(const FstClass &, MutableFstClass *, bool) + + cdef void Reweight(MutableFstClass *, const vector[WeightClass] &, + ReweightType) + + cdef cppclass RmEpsilonOptions: + + RmEpsilonOptions(QueueType, bool, const WeightClass &, int64, float) + + cdef void RmEpsilon(MutableFstClass *, const RmEpsilonOptions &) + + cdef cppclass ShortestDistanceOptions: + + ShortestDistanceOptions(QueueType, ArcFilterType, int64, float) + + cdef void ShortestDistance(const FstClass &, vector[WeightClass] *, + const ShortestDistanceOptions &) + + cdef void ShortestDistance(const FstClass &, vector[WeightClass] *, bool, + float) + + cdef cppclass ShortestPathOptions: + + ShortestPathOptions(QueueType, int32, bool, float, const WeightClass &, + int64) + + cdef void ShortestPath(const FstClass &, MutableFstClass *, + const ShortestPathOptions &) + + cdef void Synchronize(const FstClass &, MutableFstClass *) + + cdef bool TopSort(MutableFstClass *) + + cdef void Union(MutableFstClass *, const FstClass &) + + cdef bool Verify(const FstClass &) + + +cdef extern from "" namespace "fst::script" nogil: + + cdef bool GetArcSortType(const string &, ArcSortType *) + + cdef bool GetComposeFilter(const string &, ComposeFilter *) + + cdef bool GetDeterminizeType(const string &, DeterminizeType *) + + cdef uint32 GetEncodeFlags(bool, bool) + + cdef bool GetMapType(const string &, MapType *) + + cdef uint32 GetPushFlags(bool, bool, bool, bool) + + cdef bool GetQueueType(const string &, QueueType *) + + cdef bool GetRandArcSelection(const string &, RandArcSelection *) + + cdef bool GetReplaceLabelType(string, bool, ReplaceLabelType *) + + cdef ReweightType GetReweightType(bool) + + +cdef extern from "" namespace "fst" nogil: + + enum FarType: + FAR_DEFAULT + FAR_STTABLE + FAR_STLIST + FAR_FST + FAR_SSTABLE + +cdef extern from "" \ + namespace "fst" nogil: + + string GetFarTypeString(FarType) + + +cdef extern from "" \ + namespace "fst::script" nogil: + + FarType GetFarType(const string &) + + +cdef extern from "" \ + namespace "fst::script" nogil: + + cdef cppclass FarReaderClass: + + const string &ArcType() + + bool Done() + + bool Error() + + bool Find(const string &) + + const FstClass *GetFstClass() + + const string &GetKey() + + void Next() + + void Reset() + + FarType Type() + + # For simplicity, we always use the multiple-file one. + + @staticmethod + FarReaderClass *Open(const vector[string] &) + + cdef cppclass FarWriterClass: + + bool Add(const string &, const FstClass &) + + bool Error() + + const string &ArcType() + + FarType Type() + + @staticmethod + FarWriterClass *Create(const string &, const string &, FarType) diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/ios.pxd b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/ios.pxd new file mode 100644 index 0000000000..173e3c9d08 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/ios.pxd @@ -0,0 +1,77 @@ +# See www.openfst.org for extensive documentation on this weighted +# finite-state transducer library. + + +from libcpp.string cimport string +from basictypes cimport int8 +from basictypes cimport int16 +from basictypes cimport int32 +from basictypes cimport int64 +from basictypes cimport uint8 +from basictypes cimport uint16 +from basictypes cimport uint32 +from basictypes cimport uint64 + + +cdef extern from "" namespace "std" nogil: + + cdef cppclass iostream: + + pass + + cdef cppclass istream(iostream): + + pass + + cdef cppclass ostream(iostream): + + pass + + +# We are ignoring openmodes for the moment. + + +cdef extern from "" namespace "std" nogil: + + cdef cppclass ifstream(istream): + + ifstream(const string &) + + cdef cppclass ofstream(ostream): + + ofstream(const string &) + + +cdef extern from "" namespace "std" nogil: + + cdef cppclass stringstream(istream, ostream): + + stringstream() + + string str() + + stringstream &operator<<(const string &) + + stringstream &operator<<(bool) + + # We define these in terms of the Google basictypes. + + stringstream &operator<<(int8) + + stringstream &operator<<(uint8) + + stringstream &operator<<(int16) + + stringstream &operator<<(uint16) + + stringstream &operator<<(int32) + + stringstream &operator<<(uint32) + + stringstream &operator<<(int64) + + stringstream &operator<<(uint64) + + stringstream &operator<<(double) + + stringstream &operator<<(long double) diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/memory.pxd b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/memory.pxd new file mode 100644 index 0000000000..9b42eddd4f --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/memory.pxd @@ -0,0 +1,12 @@ +# See www.openfst.org for extensive documentation on this weighted +# finite-state transducer library. + + +from libcpp.memory cimport shared_ptr + + +# This is mysteriously missing from libcpp.memory. + +cdef extern from "" namespace "std" nogil: + + shared_ptr[T] static_pointer_cast[T, U](const shared_ptr[U] &) diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/pywrapfst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/pywrapfst.cc new file mode 100644 index 0000000000..e1d09e30af --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/pywrapfst.cc @@ -0,0 +1,57363 @@ +/* Generated by Cython 0.27.3 */ + +#define PY_SSIZE_T_CLEAN +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.6+ or Python 3.3+. +#else +#define CYTHON_ABI "0_27_3" +#define CYTHON_FUTURE_DIVISION 0 +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#define __PYX_COMMA , +#ifndef HAVE_LONG_LONG + #if PY_VERSION_HEX >= 0x02070000 + #define HAVE_LONG_LONG + #endif +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 +#elif defined(PYSTON_VERSION) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #define CYTHON_USE_PYTYPE_LOOKUP 1 + #endif + #if PY_MAJOR_VERSION < 3 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #define CYTHON_USE_PYLONG_INTERNALS 1 + #endif + #ifndef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if PY_VERSION_HEX < 0x030300F0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #ifndef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT (0 && PY_VERSION_HEX >= 0x03050000) + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #endif +#endif +#if !defined(CYTHON_FAST_PYCCALL) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" + #undef SHIFT + #undef BASE + #undef MASK +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#if PY_VERSION_HEX < 0x030700A0 || !defined(METH_FASTCALL) + #ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + #endif + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject **args, Py_ssize_t nargs); + typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject **args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #define __Pyx_PyCFunctionFast _PyCFunctionFast + #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords +#endif +#if CYTHON_FAST_PYCCALL +#define __Pyx_PyFastCFunction_Check(func)\ + ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS))))) +#else +#define __Pyx_PyFastCFunction_Check(func) 0 +#endif +#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x03060000 + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() +#elif PY_VERSION_HEX >= 0x03000000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#else + #define __Pyx_PyThreadState_Current _PyThreadState_Current +#endif +#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) +#else +#define __Pyx_PyDict_NewPresized(n) PyDict_New() +#endif +#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) + #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) +#else + #define CYTHON_PEP393_ENABLED 0 + #define PyUnicode_1BYTE_KIND 1 + #define PyUnicode_2BYTE_KIND 2 + #define PyUnicode_4BYTE_KIND 4 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_PYSTON + #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) + #define PyObject_ASCII(o) PyObject_Repr(o) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif +#ifndef __has_cpp_attribute + #define __has_cpp_attribute(x) 0 +#endif +#if CYTHON_USE_ASYNC_SLOTS + #if PY_VERSION_HEX >= 0x030500B1 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods + #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) + #else + #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) + #endif +#else + #define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef __Pyx_PyAsyncMethodsStruct + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + } __Pyx_PyAsyncMethodsStruct; +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) +#ifdef _MSC_VER + #ifndef _MSC_STDINT_H_ + #if _MSC_VER < 1300 + typedef unsigned char uint8_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int32 uint32_t; + #endif + #endif +#else + #include +#endif +#ifndef CYTHON_FALLTHROUGH + #if defined(__cplusplus) && __cplusplus >= 201103L + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #elif __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_attribute(fallthrough) + #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) + #else + #define CYTHON_FALLTHROUGH + #endif + #endif + #if defined(__clang__ ) && defined(__apple_build_version__) + #if __apple_build_version__ < 7000000 + #undef CYTHON_FALLTHROUGH + #define CYTHON_FALLTHROUGH + #endif + #endif +#endif + +#ifndef __cplusplus + #error "Cython files generated with the C++ option must be compiled with a C++ compiler." +#endif +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #else + #define CYTHON_INLINE inline + #endif +#endif +template +void __Pyx_call_destructor(T& x) { + x.~T(); +} +template +class __Pyx_FakeReference { + public: + __Pyx_FakeReference() : ptr(NULL) { } + __Pyx_FakeReference(const T& ref) : ptr(const_cast(&ref)) { } + T *operator->() { return ptr; } + T *operator&() { return ptr; } + operator T&() { return *ptr; } + template bool operator ==(U other) { return *ptr == other; } + template bool operator !=(U other) { return *ptr != other; } + private: + T *ptr; +}; + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + + +#define __PYX_ERR(f_index, lineno, Ln_error) \ +{ \ + __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \ +} + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__pywrapfst +#define __PYX_HAVE_API__pywrapfst +#include +#include +#include +#include "ios" +#include "new" +#include "stdexcept" +#include "typeinfo" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) + #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False)) +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +#define __Pyx_PySequence_Tuple(obj)\ + (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +#if CYTHON_ASSUME_SAFE_MACROS +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#else +#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) +#endif +#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ +static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } + +static PyObject *__pyx_m = NULL; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_cython_runtime; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static PyObject *__pyx_empty_unicode; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + + +static const char *__pyx_f[] = { + "pywrapfst.pyx", + "stringsource", +}; + +/* "basictypes.pxd":22 + * + * + * ctypedef int8_t int8 # <<<<<<<<<<<<<< + * ctypedef int16_t int16 + * ctypedef int32_t int32 + */ +typedef int8_t __pyx_t_10basictypes_int8; + +/* "basictypes.pxd":23 + * + * ctypedef int8_t int8 + * ctypedef int16_t int16 # <<<<<<<<<<<<<< + * ctypedef int32_t int32 + * ctypedef int64_t int64 + */ +typedef int16_t __pyx_t_10basictypes_int16; + +/* "basictypes.pxd":24 + * ctypedef int8_t int8 + * ctypedef int16_t int16 + * ctypedef int32_t int32 # <<<<<<<<<<<<<< + * ctypedef int64_t int64 + * ctypedef uint8_t uint8 + */ +typedef int32_t __pyx_t_10basictypes_int32; + +/* "basictypes.pxd":25 + * ctypedef int16_t int16 + * ctypedef int32_t int32 + * ctypedef int64_t int64 # <<<<<<<<<<<<<< + * ctypedef uint8_t uint8 + * ctypedef uint16_t uint16 + */ +typedef int64_t __pyx_t_10basictypes_int64; + +/* "basictypes.pxd":26 + * ctypedef int32_t int32 + * ctypedef int64_t int64 + * ctypedef uint8_t uint8 # <<<<<<<<<<<<<< + * ctypedef uint16_t uint16 + * ctypedef uint32_t uint32 + */ +typedef uint8_t __pyx_t_10basictypes_uint8; + +/* "basictypes.pxd":27 + * ctypedef int64_t int64 + * ctypedef uint8_t uint8 + * ctypedef uint16_t uint16 # <<<<<<<<<<<<<< + * ctypedef uint32_t uint32 + * ctypedef uint64_t uint64 + */ +typedef uint16_t __pyx_t_10basictypes_uint16; + +/* "basictypes.pxd":28 + * ctypedef uint8_t uint8 + * ctypedef uint16_t uint16 + * ctypedef uint32_t uint32 # <<<<<<<<<<<<<< + * ctypedef uint64_t uint64 + */ +typedef uint32_t __pyx_t_10basictypes_uint32; + +/* "basictypes.pxd":29 + * ctypedef uint16_t uint16 + * ctypedef uint32_t uint32 + * ctypedef uint64_t uint64 # <<<<<<<<<<<<<< + */ +typedef uint64_t __pyx_t_10basictypes_uint64; + +/*--- Type declarations ---*/ +struct __pyx_obj_9pywrapfst_Weight; +struct __pyx_obj_9pywrapfst__SymbolTable; +struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable; +struct __pyx_obj_9pywrapfst__FstSymbolTable; +struct __pyx_obj_9pywrapfst__MutableSymbolTable; +struct __pyx_obj_9pywrapfst__MutableFstSymbolTable; +struct __pyx_obj_9pywrapfst_SymbolTable; +struct __pyx_obj_9pywrapfst_SymbolTableIterator; +struct __pyx_obj_9pywrapfst_EncodeMapper; +struct __pyx_obj_9pywrapfst__Fst; +struct __pyx_obj_9pywrapfst__MutableFst; +struct __pyx_obj_9pywrapfst_Arc; +struct __pyx_obj_9pywrapfst_ArcIterator; +struct __pyx_obj_9pywrapfst_MutableArcIterator; +struct __pyx_obj_9pywrapfst_StateIterator; +struct __pyx_obj_9pywrapfst_Compiler; +struct __pyx_obj_9pywrapfst_FarReader; +struct __pyx_obj_9pywrapfst_FarWriter; + +/* "fst.pxd":496 + * + * + * ctypedef pair[int64, const FstClass *] LabelFstClassPair # <<<<<<<<<<<<<< + * + * ctypedef pair[int64, int64] LabelPair + */ +typedef std::pair<__pyx_t_10basictypes_int64,fst::script::FstClass const *> __pyx_t_3fst_LabelFstClassPair; + +/* "fst.pxd":498 + * ctypedef pair[int64, const FstClass *] LabelFstClassPair + * + * ctypedef pair[int64, int64] LabelPair # <<<<<<<<<<<<<< + * + * + */ +typedef std::pair<__pyx_t_10basictypes_int64,__pyx_t_10basictypes_int64> __pyx_t_3fst_LabelPair; +struct __pyx_opt_args_9pywrapfst_tostring; +struct __pyx_opt_args_9pywrapfst_weight_tostring; +struct __pyx_opt_args_9pywrapfst_19_MutableSymbolTable_add_symbol; +struct __pyx_opt_args_9pywrapfst_4_Fst_draw; +struct __pyx_opt_args_9pywrapfst_4_Fst_text; +struct __pyx_opt_args_9pywrapfst_11_MutableFst__arcsort; +struct __pyx_opt_args_9pywrapfst_11_MutableFst__closure; +struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_arcs; +struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_states; +struct __pyx_opt_args_9pywrapfst_11_MutableFst__minimize; +struct __pyx_opt_args_9pywrapfst_11_MutableFst__project; +struct __pyx_opt_args_9pywrapfst_11_MutableFst__prune; +struct __pyx_opt_args_9pywrapfst_11_MutableFst__push; +struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_pairs; +struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_tables; +struct __pyx_opt_args_9pywrapfst_11_MutableFst__reweight; +struct __pyx_opt_args_9pywrapfst_11_MutableFst__rmepsilon; +struct __pyx_opt_args_9pywrapfst_11_MutableFst__set_final; +struct __pyx_opt_args_9pywrapfst__create_Fst; +struct __pyx_opt_args_9pywrapfst__map; +struct __pyx_opt_args_9pywrapfst_arcmap; +struct __pyx_opt_args_9pywrapfst_compose; +struct __pyx_opt_args_9pywrapfst_convert; +struct __pyx_opt_args_9pywrapfst_determinize; +struct __pyx_opt_args_9pywrapfst_difference; +struct __pyx_opt_args_9pywrapfst_disambiguate; +struct __pyx_opt_args_9pywrapfst_epsnormalize; +struct __pyx_opt_args_9pywrapfst_equal; +struct __pyx_opt_args_9pywrapfst_equivalent; +struct __pyx_opt_args_9pywrapfst_intersect; +struct __pyx_opt_args_9pywrapfst_isomorphic; +struct __pyx_opt_args_9pywrapfst_prune; +struct __pyx_opt_args_9pywrapfst_push; +struct __pyx_opt_args_9pywrapfst_randequivalent; +struct __pyx_opt_args_9pywrapfst_randgen; +struct __pyx_opt_args_9pywrapfst_replace; +struct __pyx_opt_args_9pywrapfst_reverse; +struct __pyx_opt_args_9pywrapfst__shortestdistance; +struct __pyx_opt_args_9pywrapfst_shortestpath; + +/* "pywrapfst.pxd":41 + * + * + * cdef string tostring(data, encoding=?) except * # <<<<<<<<<<<<<< + * + * cdef string weight_tostring(data, encoding=?) except * + */ +struct __pyx_opt_args_9pywrapfst_tostring { + int __pyx_n; + PyObject *encoding; +}; + +/* "pywrapfst.pxd":43 + * cdef string tostring(data, encoding=?) except * + * + * cdef string weight_tostring(data, encoding=?) except * # <<<<<<<<<<<<<< + * + * cdef fst.ComposeFilter _get_compose_filter( + */ +struct __pyx_opt_args_9pywrapfst_weight_tostring { + int __pyx_n; + PyObject *encoding; +}; + +/* "pywrapfst.pxd":99 + * # SymbolTable. + * + * ctypedef fst.SymbolTable * SymbolTable_ptr # <<<<<<<<<<<<<< + * + * + */ +typedef fst::SymbolTable *__pyx_t_9pywrapfst_SymbolTable_ptr; + +/* "pywrapfst.pxd":139 + * cdef class _MutableSymbolTable(_SymbolTable): + * + * cpdef int64 add_symbol(self, symbol, int64 key=?) # <<<<<<<<<<<<<< + * + * cpdef void add_table(self, _SymbolTable syms) + */ +struct __pyx_opt_args_9pywrapfst_19_MutableSymbolTable_add_symbol { + int __pyx_n; + __pyx_t_10basictypes_int64 key; +}; + +/* "pywrapfst.pxd":215 + * + * + * ctypedef fst.FstClass * FstClass_ptr # <<<<<<<<<<<<<< + * ctypedef fst.MutableFstClass * MutableFstClass_ptr + * ctypedef fst.VectorFstClass * VectorFstClass_ptr + */ +typedef fst::script::FstClass *__pyx_t_9pywrapfst_FstClass_ptr; + +/* "pywrapfst.pxd":216 + * + * ctypedef fst.FstClass * FstClass_ptr + * ctypedef fst.MutableFstClass * MutableFstClass_ptr # <<<<<<<<<<<<<< + * ctypedef fst.VectorFstClass * VectorFstClass_ptr + * + */ +typedef fst::script::MutableFstClass *__pyx_t_9pywrapfst_MutableFstClass_ptr; + +/* "pywrapfst.pxd":217 + * ctypedef fst.FstClass * FstClass_ptr + * ctypedef fst.MutableFstClass * MutableFstClass_ptr + * ctypedef fst.VectorFstClass * VectorFstClass_ptr # <<<<<<<<<<<<<< + * + * + */ +typedef fst::script::VectorFstClass *__pyx_t_9pywrapfst_VectorFstClass_ptr; + +/* "pywrapfst.pxd":230 + * cpdef _Fst copy(self) + * + * cpdef void draw(self, filename, _SymbolTable isymbols=?, # <<<<<<<<<<<<<< + * _SymbolTable osymbols=?, SymbolTable ssymbols=?, + * bool acceptor=?, title=?, double width=?, + */ +struct __pyx_opt_args_9pywrapfst_4_Fst_draw { + int __pyx_n; + struct __pyx_obj_9pywrapfst__SymbolTable *isymbols; + struct __pyx_obj_9pywrapfst__SymbolTable *osymbols; + struct __pyx_obj_9pywrapfst_SymbolTable *ssymbols; + bool acceptor; + PyObject *title; + double width; + double height; + bool portrait; + bool vertical; + double ranksep; + double nodesep; + __pyx_t_10basictypes_int32 fontsize; + __pyx_t_10basictypes_int32 precision; + PyObject *float_format; + bool show_weight_one; +}; + +/* "pywrapfst.pxd":258 + * cpdef StateIterator states(self) + * + * cpdef string text(self, _SymbolTable isymbols=?, _SymbolTable osymbols=?, # <<<<<<<<<<<<<< + * _SymbolTable ssymbols=?, bool acceptor=?, + * bool show_weight_one=?, missing_sym=?) + */ +struct __pyx_opt_args_9pywrapfst_4_Fst_text { + int __pyx_n; + struct __pyx_obj_9pywrapfst__SymbolTable *isymbols; + struct __pyx_obj_9pywrapfst__SymbolTable *osymbols; + struct __pyx_obj_9pywrapfst__SymbolTable *ssymbols; + bool acceptor; + bool show_weight_one; + PyObject *missing_sym; +}; + +/* "pywrapfst.pxd":281 + * cpdef int64 add_state(self) except * + * + * cdef void _arcsort(self, sort_type=?) except * # <<<<<<<<<<<<<< + * + * cdef void _closure(self, bool closure_plus=?) except * + */ +struct __pyx_opt_args_9pywrapfst_11_MutableFst__arcsort { + int __pyx_n; + PyObject *sort_type; +}; + +/* "pywrapfst.pxd":283 + * cdef void _arcsort(self, sort_type=?) except * + * + * cdef void _closure(self, bool closure_plus=?) except * # <<<<<<<<<<<<<< + * + * cdef void _concat(self, _Fst ifst) except * + */ +struct __pyx_opt_args_9pywrapfst_11_MutableFst__closure { + int __pyx_n; + bool closure_plus; +}; + +/* "pywrapfst.pxd":291 + * cdef void _decode(self, EncodeMapper) except * + * + * cdef void _delete_arcs(self, int64 state, size_t n=?) except * # <<<<<<<<<<<<<< + * + * cdef void _delete_states(self, states=?) except * + */ +struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_arcs { + int __pyx_n; + size_t n; +}; + +/* "pywrapfst.pxd":293 + * cdef void _delete_arcs(self, int64 state, size_t n=?) except * + * + * cdef void _delete_states(self, states=?) except * # <<<<<<<<<<<<<< + * + * cdef void _encode(self, EncodeMapper) except * + */ +struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_states { + int __pyx_n; + PyObject *states; +}; + +/* "pywrapfst.pxd":299 + * cdef void _invert(self) except * + * + * cdef void _minimize(self, float delta=?, bool allow_nondet=?) except * # <<<<<<<<<<<<<< + * + * cpdef MutableArcIterator mutable_arcs(self, int64 state) + */ +struct __pyx_opt_args_9pywrapfst_11_MutableFst__minimize { + int __pyx_n; + float delta; + bool allow_nondet; +}; + +/* "pywrapfst.pxd":305 + * cpdef int64 num_states(self) + * + * cdef void _project(self, bool project_output=?) except * # <<<<<<<<<<<<<< + * + * cdef void _prune(self, float delta=?, int64 nstate=?, weight=?) except * + */ +struct __pyx_opt_args_9pywrapfst_11_MutableFst__project { + int __pyx_n; + bool project_output; +}; + +/* "pywrapfst.pxd":307 + * cdef void _project(self, bool project_output=?) except * + * + * cdef void _prune(self, float delta=?, int64 nstate=?, weight=?) except * # <<<<<<<<<<<<<< + * + * cdef void _push(self, float delta=?, bool remove_total_weight=?, + */ +struct __pyx_opt_args_9pywrapfst_11_MutableFst__prune { + int __pyx_n; + float delta; + __pyx_t_10basictypes_int64 nstate; + PyObject *weight; +}; + +/* "pywrapfst.pxd":309 + * cdef void _prune(self, float delta=?, int64 nstate=?, weight=?) except * + * + * cdef void _push(self, float delta=?, bool remove_total_weight=?, # <<<<<<<<<<<<<< + * bool to_final=?) except * + * + */ +struct __pyx_opt_args_9pywrapfst_11_MutableFst__push { + int __pyx_n; + float delta; + bool remove_total_weight; + bool to_final; +}; + +/* "pywrapfst.pxd":312 + * bool to_final=?) except * + * + * cdef void _relabel_pairs(self, ipairs=?, opairs=?) except * # <<<<<<<<<<<<<< + * + * cdef void _relabel_tables(self, _SymbolTable old_isymbols=?, + */ +struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_pairs { + int __pyx_n; + PyObject *ipairs; + PyObject *opairs; +}; + +/* "pywrapfst.pxd":314 + * cdef void _relabel_pairs(self, ipairs=?, opairs=?) except * + * + * cdef void _relabel_tables(self, _SymbolTable old_isymbols=?, # <<<<<<<<<<<<<< + * _SymbolTable new_isymbols=?, unknown_isymbol=?, + * bool attach_new_isymbols=?, + */ +struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_tables { + int __pyx_n; + struct __pyx_obj_9pywrapfst__SymbolTable *old_isymbols; + struct __pyx_obj_9pywrapfst__SymbolTable *new_isymbols; + PyObject *unknown_isymbol; + bool attach_new_isymbols; + struct __pyx_obj_9pywrapfst__SymbolTable *old_osymbols; + struct __pyx_obj_9pywrapfst__SymbolTable *new_osymbols; + PyObject *unknown_osymbol; + bool attach_new_osymbols; +}; + +/* "pywrapfst.pxd":324 + * cdef void _reserve_states(self, int64 n) except * + * + * cdef void _reweight(self, potentials, bool to_final=?) except * # <<<<<<<<<<<<<< + * + * cdef void _rmepsilon(self, queue_type=?, bool connect=?, weight=?, + */ +struct __pyx_opt_args_9pywrapfst_11_MutableFst__reweight { + int __pyx_n; + bool to_final; +}; + +/* "pywrapfst.pxd":326 + * cdef void _reweight(self, potentials, bool to_final=?) except * + * + * cdef void _rmepsilon(self, queue_type=?, bool connect=?, weight=?, # <<<<<<<<<<<<<< + * int64 nstate=?, float delta=?) except * + * + */ +struct __pyx_opt_args_9pywrapfst_11_MutableFst__rmepsilon { + int __pyx_n; + PyObject *queue_type; + bool connect; + PyObject *weight; + __pyx_t_10basictypes_int64 nstate; + float delta; +}; + +/* "pywrapfst.pxd":329 + * int64 nstate=?, float delta=?) except * + * + * cdef void _set_final(self, int64 state, weight=?) except * # <<<<<<<<<<<<<< + * + * cdef void _set_properties(self, uint64 props, uint64 mask) + */ +struct __pyx_opt_args_9pywrapfst_11_MutableFst__set_final { + int __pyx_n; + PyObject *weight; +}; + +/* "pywrapfst.pxd":353 + * cdef _Fst _init_XFst(FstClass_ptr tfst) + * + * cdef _MutableFst _create_Fst(arc_type=?) # <<<<<<<<<<<<<< + * + * cpdef _Fst _read(filename) + */ +struct __pyx_opt_args_9pywrapfst__create_Fst { + int __pyx_n; + PyObject *arc_type; +}; + +/* "pywrapfst.pxd":436 + * + * + * cdef _Fst _map(_Fst ifst, float delta=?, map_type=?, double power=?, weight=?) # <<<<<<<<<<<<<< + * + * cpdef _Fst arcmap(_Fst ifst, float delta=?, map_type=?, double power=?, weight=?) + */ +struct __pyx_opt_args_9pywrapfst__map { + int __pyx_n; + float delta; + PyObject *map_type; + double power; + PyObject *weight; +}; + +/* "pywrapfst.pxd":438 + * cdef _Fst _map(_Fst ifst, float delta=?, map_type=?, double power=?, weight=?) + * + * cpdef _Fst arcmap(_Fst ifst, float delta=?, map_type=?, double power=?, weight=?) # <<<<<<<<<<<<<< + * + * cpdef _MutableFst compose(_Fst ifst1, _Fst ifst2, compose_filter=?, + */ +struct __pyx_opt_args_9pywrapfst_arcmap { + int __pyx_n; + float delta; + PyObject *map_type; + double power; + PyObject *weight; +}; + +/* "pywrapfst.pxd":440 + * cpdef _Fst arcmap(_Fst ifst, float delta=?, map_type=?, double power=?, weight=?) + * + * cpdef _MutableFst compose(_Fst ifst1, _Fst ifst2, compose_filter=?, # <<<<<<<<<<<<<< + * bool connect=?) + * + */ +struct __pyx_opt_args_9pywrapfst_compose { + int __pyx_n; + PyObject *compose_filter; + bool connect; +}; + +/* "pywrapfst.pxd":443 + * bool connect=?) + * + * cpdef _Fst convert(_Fst ifst, fst_type=?) # <<<<<<<<<<<<<< + * + * cpdef _MutableFst determinize(_Fst ifst, float delta=?, det_type=?, + */ +struct __pyx_opt_args_9pywrapfst_convert { + int __pyx_n; + PyObject *fst_type; +}; + +/* "pywrapfst.pxd":445 + * cpdef _Fst convert(_Fst ifst, fst_type=?) + * + * cpdef _MutableFst determinize(_Fst ifst, float delta=?, det_type=?, # <<<<<<<<<<<<<< + * int64 nstate=?, int64 subsequential_label=?, + * weight=?, bool increment_subsequential_label=?) + */ +struct __pyx_opt_args_9pywrapfst_determinize { + int __pyx_n; + float delta; + PyObject *det_type; + __pyx_t_10basictypes_int64 nstate; + __pyx_t_10basictypes_int64 subsequential_label; + PyObject *weight; + bool increment_subsequential_label; +}; + +/* "pywrapfst.pxd":449 + * weight=?, bool increment_subsequential_label=?) + * + * cpdef _MutableFst difference(_Fst ifst1, _Fst ifst2, compose_filter=?, # <<<<<<<<<<<<<< + * bool connect=?) + * + */ +struct __pyx_opt_args_9pywrapfst_difference { + int __pyx_n; + PyObject *compose_filter; + bool connect; +}; + +/* "pywrapfst.pxd":452 + * bool connect=?) + * + * cpdef _MutableFst disambiguate(_Fst ifst, float delta=?, int64 nstate=?, # <<<<<<<<<<<<<< + * int64 subsequential_label=?, weight=?) + * + */ +struct __pyx_opt_args_9pywrapfst_disambiguate { + int __pyx_n; + float delta; + __pyx_t_10basictypes_int64 nstate; + __pyx_t_10basictypes_int64 subsequential_label; + PyObject *weight; +}; + +/* "pywrapfst.pxd":455 + * int64 subsequential_label=?, weight=?) + * + * cpdef _MutableFst epsnormalize(_Fst ifst, bool eps_norm_output=?) # <<<<<<<<<<<<<< + * + * cpdef bool equal(_Fst ifst1, _Fst ifst2, float delta=?) + */ +struct __pyx_opt_args_9pywrapfst_epsnormalize { + int __pyx_n; + bool eps_norm_output; +}; + +/* "pywrapfst.pxd":457 + * cpdef _MutableFst epsnormalize(_Fst ifst, bool eps_norm_output=?) + * + * cpdef bool equal(_Fst ifst1, _Fst ifst2, float delta=?) # <<<<<<<<<<<<<< + * + * cpdef bool equivalent(_Fst ifst1, _Fst ifst2, float delta=?) except * + */ +struct __pyx_opt_args_9pywrapfst_equal { + int __pyx_n; + float delta; +}; + +/* "pywrapfst.pxd":459 + * cpdef bool equal(_Fst ifst1, _Fst ifst2, float delta=?) + * + * cpdef bool equivalent(_Fst ifst1, _Fst ifst2, float delta=?) except * # <<<<<<<<<<<<<< + * + * cpdef _MutableFst intersect(_Fst ifst1, _Fst ifst2, compose_filter=?, + */ +struct __pyx_opt_args_9pywrapfst_equivalent { + int __pyx_n; + float delta; +}; + +/* "pywrapfst.pxd":461 + * cpdef bool equivalent(_Fst ifst1, _Fst ifst2, float delta=?) except * + * + * cpdef _MutableFst intersect(_Fst ifst1, _Fst ifst2, compose_filter=?, # <<<<<<<<<<<<<< + * bool connect=?) + * + */ +struct __pyx_opt_args_9pywrapfst_intersect { + int __pyx_n; + PyObject *compose_filter; + bool connect; +}; + +/* "pywrapfst.pxd":464 + * bool connect=?) + * + * cpdef bool isomorphic(_Fst ifst1, _Fst ifst2, float delta=?) # <<<<<<<<<<<<<< + * + * cpdef _MutableFst prune(_Fst ifst, float delta=?, int64 nstate=?, + */ +struct __pyx_opt_args_9pywrapfst_isomorphic { + int __pyx_n; + float delta; +}; + +/* "pywrapfst.pxd":466 + * cpdef bool isomorphic(_Fst ifst1, _Fst ifst2, float delta=?) + * + * cpdef _MutableFst prune(_Fst ifst, float delta=?, int64 nstate=?, # <<<<<<<<<<<<<< + * weight=?) + * + */ +struct __pyx_opt_args_9pywrapfst_prune { + int __pyx_n; + float delta; + __pyx_t_10basictypes_int64 nstate; + PyObject *weight; +}; + +/* "pywrapfst.pxd":469 + * weight=?) + * + * cpdef _MutableFst push(_Fst ifst, float delta=?, bool push_weights=?, # <<<<<<<<<<<<<< + * bool push_labels=?, bool remove_common_affix=?, + * bool remove_total_weight=?, bool to_final=?) + */ +struct __pyx_opt_args_9pywrapfst_push { + int __pyx_n; + float delta; + bool push_weights; + bool push_labels; + bool remove_common_affix; + bool remove_total_weight; + bool to_final; +}; + +/* "pywrapfst.pxd":473 + * bool remove_total_weight=?, bool to_final=?) + * + * cpdef bool randequivalent(_Fst ifst1, _Fst ifst2, int32 npath=?, # <<<<<<<<<<<<<< + * float delta=?, time_t seed=?, select=?, + * int32 max_length=?) except * + */ +struct __pyx_opt_args_9pywrapfst_randequivalent { + int __pyx_n; + __pyx_t_10basictypes_int32 npath; + float delta; + time_t seed; + PyObject *select; + __pyx_t_10basictypes_int32 max_length; +}; + +/* "pywrapfst.pxd":477 + * int32 max_length=?) except * + * + * cpdef _MutableFst randgen(_Fst ifst, int32 npath=?, time_t seed=?, # <<<<<<<<<<<<<< + * select=?, int32 max_length=?, + * bool remove_total_weight=?, bool weighted=?) + */ +struct __pyx_opt_args_9pywrapfst_randgen { + int __pyx_n; + __pyx_t_10basictypes_int32 npath; + time_t seed; + PyObject *select; + __pyx_t_10basictypes_int32 max_length; + bool remove_total_weight; + bool weighted; +}; + +/* "pywrapfst.pxd":484 + * bool epsilon_on_replace) except * + * + * cpdef _MutableFst replace(pairs, call_arc_labeling=?, return_arc_labeling=?, # <<<<<<<<<<<<<< + * bool epsilon_on_replace=?, int64 return_label=?) + * + */ +struct __pyx_opt_args_9pywrapfst_replace { + int __pyx_n; + PyObject *call_arc_labeling; + PyObject *return_arc_labeling; + bool epsilon_on_replace; + __pyx_t_10basictypes_int64 return_label; +}; + +/* "pywrapfst.pxd":487 + * bool epsilon_on_replace=?, int64 return_label=?) + * + * cpdef _MutableFst reverse(_Fst ifst, bool require_superinitial=?) # <<<<<<<<<<<<<< + * + * cdef vector[fst.WeightClass] *_shortestdistance(_Fst ifst, float delta=?, + */ +struct __pyx_opt_args_9pywrapfst_reverse { + int __pyx_n; + bool require_superinitial; +}; + +/* "pywrapfst.pxd":489 + * cpdef _MutableFst reverse(_Fst ifst, bool require_superinitial=?) + * + * cdef vector[fst.WeightClass] *_shortestdistance(_Fst ifst, float delta=?, # <<<<<<<<<<<<<< + * int64 nstate=?, queue_type=?, + * bool reverse=?) except * + */ +struct __pyx_opt_args_9pywrapfst__shortestdistance { + int __pyx_n; + float delta; + __pyx_t_10basictypes_int64 nstate; + PyObject *queue_type; + bool reverse; +}; + +/* "pywrapfst.pxd":493 + * bool reverse=?) except * + * + * cpdef _MutableFst shortestpath(_Fst ifst, float delta=?, int32 nshortest=?, # <<<<<<<<<<<<<< + * int64 nstate=?, queue_type=?, bool unique=?, + * weight=?) + */ +struct __pyx_opt_args_9pywrapfst_shortestpath { + int __pyx_n; + float delta; + __pyx_t_10basictypes_int32 nshortest; + __pyx_t_10basictypes_int64 nstate; + PyObject *queue_type; + bool unique; + PyObject *weight; +}; + +/* "pywrapfst.pxd":69 + * + * + * cdef class Weight(object): # <<<<<<<<<<<<<< + * + * cdef unique_ptr[fst.WeightClass] _weight + */ +struct __pyx_obj_9pywrapfst_Weight { + PyObject_HEAD + struct __pyx_vtabstruct_9pywrapfst_Weight *__pyx_vtab; + std::unique_ptr _weight; +}; + + +/* "pywrapfst.pxd":102 + * + * + * cdef class _SymbolTable(object): # <<<<<<<<<<<<<< + * + * cdef fst.SymbolTable *_table + */ +struct __pyx_obj_9pywrapfst__SymbolTable { + PyObject_HEAD + struct __pyx_vtabstruct_9pywrapfst__SymbolTable *__pyx_vtab; + fst::SymbolTable *_table; +}; + + +/* "pywrapfst.pxd":127 + * + * + * cdef class _EncodeMapperSymbolTable(_SymbolTable): # <<<<<<<<<<<<<< + * + * cdef shared_ptr[fst.EncodeMapperClass] _encoder + */ +struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable { + struct __pyx_obj_9pywrapfst__SymbolTable __pyx_base; + std::shared_ptr _encoder; +}; + + +/* "pywrapfst.pxd":132 + * + * + * cdef class _FstSymbolTable(_SymbolTable): # <<<<<<<<<<<<<< + * + * cdef shared_ptr[fst.FstClass] _fst + */ +struct __pyx_obj_9pywrapfst__FstSymbolTable { + struct __pyx_obj_9pywrapfst__SymbolTable __pyx_base; + std::shared_ptr _fst; +}; + + +/* "pywrapfst.pxd":137 + * + * + * cdef class _MutableSymbolTable(_SymbolTable): # <<<<<<<<<<<<<< + * + * cpdef int64 add_symbol(self, symbol, int64 key=?) + */ +struct __pyx_obj_9pywrapfst__MutableSymbolTable { + struct __pyx_obj_9pywrapfst__SymbolTable __pyx_base; +}; + + +/* "pywrapfst.pxd":146 + * + * + * cdef class _MutableFstSymbolTable(_MutableSymbolTable): # <<<<<<<<<<<<<< + * + * cdef shared_ptr[fst.MutableFstClass] _mfst + */ +struct __pyx_obj_9pywrapfst__MutableFstSymbolTable { + struct __pyx_obj_9pywrapfst__MutableSymbolTable __pyx_base; + std::shared_ptr _mfst; +}; + + +/* "pywrapfst.pxd":151 + * + * + * cdef class SymbolTable(_MutableSymbolTable): # <<<<<<<<<<<<<< + * + * cdef unique_ptr[fst.SymbolTable] _smart_table + */ +struct __pyx_obj_9pywrapfst_SymbolTable { + struct __pyx_obj_9pywrapfst__MutableSymbolTable __pyx_base; + std::unique_ptr _smart_table; +}; + + +/* "pywrapfst.pxd":172 + * + * + * cdef class SymbolTableIterator(object): # <<<<<<<<<<<<<< + * + * cdef shared_ptr[fst.SymbolTable] _table + */ +struct __pyx_obj_9pywrapfst_SymbolTableIterator { + PyObject_HEAD + struct __pyx_vtabstruct_9pywrapfst_SymbolTableIterator *__pyx_vtab; + std::shared_ptr _table; + std::unique_ptr _siter; +}; + + +/* "pywrapfst.pxd":191 + * + * + * cdef class EncodeMapper(object): # <<<<<<<<<<<<<< + * + * cdef shared_ptr[fst.EncodeMapperClass] _encoder + */ +struct __pyx_obj_9pywrapfst_EncodeMapper { + PyObject_HEAD + struct __pyx_vtabstruct_9pywrapfst_EncodeMapper *__pyx_vtab; + std::shared_ptr _encoder; +}; + + +/* "pywrapfst.pxd":220 + * + * + * cdef class _Fst(object): # <<<<<<<<<<<<<< + * + * cdef shared_ptr[fst.FstClass] _fst + */ +struct __pyx_obj_9pywrapfst__Fst { + PyObject_HEAD + struct __pyx_vtabstruct_9pywrapfst__Fst *__pyx_vtab; + std::shared_ptr _fst; +}; + + +/* "pywrapfst.pxd":271 + * + * + * cdef class _MutableFst(_Fst): # <<<<<<<<<<<<<< + * + * cdef shared_ptr[fst.MutableFstClass] _mfst + */ +struct __pyx_obj_9pywrapfst__MutableFst { + struct __pyx_obj_9pywrapfst__Fst __pyx_base; + std::shared_ptr _mfst; +}; + + +/* "pywrapfst.pxd":363 + * + * + * cdef class Arc(object): # <<<<<<<<<<<<<< + * + * cdef unique_ptr[fst.ArcClass] _arc + */ +struct __pyx_obj_9pywrapfst_Arc { + PyObject_HEAD + struct __pyx_vtabstruct_9pywrapfst_Arc *__pyx_vtab; + std::unique_ptr _arc; +}; + + +/* "pywrapfst.pxd":373 + * + * + * cdef class ArcIterator(object): # <<<<<<<<<<<<<< + * + * cdef shared_ptr[fst.FstClass] _fst + */ +struct __pyx_obj_9pywrapfst_ArcIterator { + PyObject_HEAD + struct __pyx_vtabstruct_9pywrapfst_ArcIterator *__pyx_vtab; + std::shared_ptr _fst; + std::unique_ptr _aiter; +}; + + +/* "pywrapfst.pxd":395 + * + * + * cdef class MutableArcIterator(object): # <<<<<<<<<<<<<< + * + * cdef shared_ptr[fst.MutableFstClass] _mfst + */ +struct __pyx_obj_9pywrapfst_MutableArcIterator { + PyObject_HEAD + struct __pyx_vtabstruct_9pywrapfst_MutableArcIterator *__pyx_vtab; + std::shared_ptr _mfst; + std::unique_ptr _aiter; +}; + + +/* "pywrapfst.pxd":419 + * + * + * cdef class StateIterator(object): # <<<<<<<<<<<<<< + * + * cdef shared_ptr[fst.FstClass] _fst + */ +struct __pyx_obj_9pywrapfst_StateIterator { + PyObject_HEAD + struct __pyx_vtabstruct_9pywrapfst_StateIterator *__pyx_vtab; + std::shared_ptr _fst; + std::unique_ptr _siter; +}; + + +/* "pywrapfst.pxd":505 + * + * + * cdef class Compiler(object): # <<<<<<<<<<<<<< + * + * cdef unique_ptr[stringstream] _sstrm + */ +struct __pyx_obj_9pywrapfst_Compiler { + PyObject_HEAD + struct __pyx_vtabstruct_9pywrapfst_Compiler *__pyx_vtab; + std::unique_ptr _sstrm; + std::string _fst_type; + std::string _arc_type; + fst::SymbolTable const *_isymbols; + fst::SymbolTable const *_osymbols; + fst::SymbolTable const *_ssymbols; + bool _acceptor; + bool _keep_isymbols; + bool _keep_osymbols; + bool _keep_state_numbering; + bool _allow_negative_labels; +}; + + +/* "pywrapfst.pxd":526 + * # FarReader. + * + * cdef class FarReader(object): # <<<<<<<<<<<<<< + * + * cdef unique_ptr[fst.FarReaderClass] _reader + */ +struct __pyx_obj_9pywrapfst_FarReader { + PyObject_HEAD + struct __pyx_vtabstruct_9pywrapfst_FarReader *__pyx_vtab; + std::unique_ptr _reader; +}; + + +/* "pywrapfst.pxd":551 + * # FarWriter. + * + * cdef class FarWriter(object): # <<<<<<<<<<<<<< + * + * cdef unique_ptr[fst.FarWriterClass] _writer + */ +struct __pyx_obj_9pywrapfst_FarWriter { + PyObject_HEAD + struct __pyx_vtabstruct_9pywrapfst_FarWriter *__pyx_vtab; + std::unique_ptr _writer; +}; + + + +/* "pywrapfst.pyx":348 + * + * + * cdef class Weight(object): # <<<<<<<<<<<<<< + * + * """ + */ + +struct __pyx_vtabstruct_9pywrapfst_Weight { + void (*_check_weight)(struct __pyx_obj_9pywrapfst_Weight *); + struct __pyx_obj_9pywrapfst_Weight *(*copy)(struct __pyx_obj_9pywrapfst_Weight *, int __pyx_skip_dispatch); + std::string (*to_string)(struct __pyx_obj_9pywrapfst_Weight *, int __pyx_skip_dispatch); + std::string (*type)(struct __pyx_obj_9pywrapfst_Weight *, int __pyx_skip_dispatch); +}; +static struct __pyx_vtabstruct_9pywrapfst_Weight *__pyx_vtabptr_9pywrapfst_Weight; + + +/* "pywrapfst.pyx":675 + * + * + * cdef class _SymbolTable(object): # <<<<<<<<<<<<<< + * + * """ + */ + +struct __pyx_vtabstruct_9pywrapfst__SymbolTable { + __pyx_t_10basictypes_int64 (*available_key)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch); + std::string (*checksum)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch); + struct __pyx_obj_9pywrapfst_SymbolTable *(*copy)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch); + __pyx_t_10basictypes_int64 (*get_nth_key)(struct __pyx_obj_9pywrapfst__SymbolTable *, Py_ssize_t, int __pyx_skip_dispatch); + std::string (*labeled_checksum)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch); + bool (*member)(struct __pyx_obj_9pywrapfst__SymbolTable *, PyObject *, int __pyx_skip_dispatch); + std::string (*name)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch); + size_t (*num_symbols)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch); + void (*write)(struct __pyx_obj_9pywrapfst__SymbolTable *, PyObject *, int __pyx_skip_dispatch); + void (*write_text)(struct __pyx_obj_9pywrapfst__SymbolTable *, PyObject *, int __pyx_skip_dispatch); +}; +static struct __pyx_vtabstruct_9pywrapfst__SymbolTable *__pyx_vtabptr_9pywrapfst__SymbolTable; + + +/* "pywrapfst.pyx":839 + * + * + * cdef class _EncodeMapperSymbolTable(_SymbolTable): # <<<<<<<<<<<<<< + * + * """ + */ + +struct __pyx_vtabstruct_9pywrapfst__EncodeMapperSymbolTable { + struct __pyx_vtabstruct_9pywrapfst__SymbolTable __pyx_base; +}; +static struct __pyx_vtabstruct_9pywrapfst__EncodeMapperSymbolTable *__pyx_vtabptr_9pywrapfst__EncodeMapperSymbolTable; + + +/* "pywrapfst.pyx":859 + * + * + * cdef class _FstSymbolTable(_SymbolTable): # <<<<<<<<<<<<<< + * + * """ + */ + +struct __pyx_vtabstruct_9pywrapfst__FstSymbolTable { + struct __pyx_vtabstruct_9pywrapfst__SymbolTable __pyx_base; +}; +static struct __pyx_vtabstruct_9pywrapfst__FstSymbolTable *__pyx_vtabptr_9pywrapfst__FstSymbolTable; + + +/* "pywrapfst.pyx":878 + * + * + * cdef class _MutableSymbolTable(_SymbolTable): # <<<<<<<<<<<<<< + * + * """ + */ + +struct __pyx_vtabstruct_9pywrapfst__MutableSymbolTable { + struct __pyx_vtabstruct_9pywrapfst__SymbolTable __pyx_base; + __pyx_t_10basictypes_int64 (*add_symbol)(struct __pyx_obj_9pywrapfst__MutableSymbolTable *, PyObject *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_19_MutableSymbolTable_add_symbol *__pyx_optional_args); + void (*add_table)(struct __pyx_obj_9pywrapfst__MutableSymbolTable *, struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch); + void (*set_name)(struct __pyx_obj_9pywrapfst__MutableSymbolTable *, PyObject *, int __pyx_skip_dispatch); +}; +static struct __pyx_vtabstruct_9pywrapfst__MutableSymbolTable *__pyx_vtabptr_9pywrapfst__MutableSymbolTable; + + +/* "pywrapfst.pyx":930 + * + * + * cdef class _MutableFstSymbolTable(_MutableSymbolTable): # <<<<<<<<<<<<<< + * """ + * (No constructor.) + */ + +struct __pyx_vtabstruct_9pywrapfst__MutableFstSymbolTable { + struct __pyx_vtabstruct_9pywrapfst__MutableSymbolTable __pyx_base; +}; +static struct __pyx_vtabstruct_9pywrapfst__MutableFstSymbolTable *__pyx_vtabptr_9pywrapfst__MutableFstSymbolTable; + + +/* "pywrapfst.pyx":941 + * + * + * cdef class SymbolTable(_MutableSymbolTable): # <<<<<<<<<<<<<< + * + * """ + */ + +struct __pyx_vtabstruct_9pywrapfst_SymbolTable { + struct __pyx_vtabstruct_9pywrapfst__MutableSymbolTable __pyx_base; +}; +static struct __pyx_vtabstruct_9pywrapfst_SymbolTable *__pyx_vtabptr_9pywrapfst_SymbolTable; + + +/* "pywrapfst.pyx":1124 + * + * + * cdef class SymbolTableIterator(object): # <<<<<<<<<<<<<< + * + * """ + */ + +struct __pyx_vtabstruct_9pywrapfst_SymbolTableIterator { + bool (*done)(struct __pyx_obj_9pywrapfst_SymbolTableIterator *, int __pyx_skip_dispatch); + void (*next)(struct __pyx_obj_9pywrapfst_SymbolTableIterator *, int __pyx_skip_dispatch); + void (*reset)(struct __pyx_obj_9pywrapfst_SymbolTableIterator *, int __pyx_skip_dispatch); + std::string (*symbol)(struct __pyx_obj_9pywrapfst_SymbolTableIterator *, int __pyx_skip_dispatch); + __pyx_t_10basictypes_int64 (*value)(struct __pyx_obj_9pywrapfst_SymbolTableIterator *, int __pyx_skip_dispatch); +}; +static struct __pyx_vtabstruct_9pywrapfst_SymbolTableIterator *__pyx_vtabptr_9pywrapfst_SymbolTableIterator; + + +/* "pywrapfst.pyx":1206 + * + * + * cdef class EncodeMapper(object): # <<<<<<<<<<<<<< + * + * """ + */ + +struct __pyx_vtabstruct_9pywrapfst_EncodeMapper { + std::string (*arc_type)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch); + __pyx_t_10basictypes_uint32 (*flags)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch); + struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *(*input_symbols)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch); + struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *(*output_symbols)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch); + __pyx_t_10basictypes_uint64 (*properties)(struct __pyx_obj_9pywrapfst_EncodeMapper *, __pyx_t_10basictypes_uint64, int __pyx_skip_dispatch); + void (*set_input_symbols)(struct __pyx_obj_9pywrapfst_EncodeMapper *, struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch); + void (*set_output_symbols)(struct __pyx_obj_9pywrapfst_EncodeMapper *, struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch); + std::string (*weight_type)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch); +}; +static struct __pyx_vtabstruct_9pywrapfst_EncodeMapper *__pyx_vtabptr_9pywrapfst_EncodeMapper; + + +/* "pywrapfst.pyx":1362 + * + * + * cdef class _Fst(object): # <<<<<<<<<<<<<< + * + * """ + */ + +struct __pyx_vtabstruct_9pywrapfst__Fst { + std::string (*arc_type)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch); + struct __pyx_obj_9pywrapfst_ArcIterator *(*arcs)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch); + struct __pyx_obj_9pywrapfst__Fst *(*copy)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch); + void (*draw)(struct __pyx_obj_9pywrapfst__Fst *, PyObject *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_4_Fst_draw *__pyx_optional_args); + struct __pyx_obj_9pywrapfst_Weight *(*final)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch); + std::string (*fst_type)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch); + struct __pyx_obj_9pywrapfst__FstSymbolTable *(*input_symbols)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch); + size_t (*num_arcs)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch); + size_t (*num_input_epsilons)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch); + size_t (*num_output_epsilons)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch); + struct __pyx_obj_9pywrapfst__FstSymbolTable *(*output_symbols)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch); + __pyx_t_10basictypes_uint64 (*properties)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_uint64, bool, int __pyx_skip_dispatch); + __pyx_t_10basictypes_int64 (*start)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch); + struct __pyx_obj_9pywrapfst_StateIterator *(*states)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch); + std::string (*text)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_4_Fst_text *__pyx_optional_args); + bool (*verify)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch); + std::string (*weight_type)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch); + void (*write)(struct __pyx_obj_9pywrapfst__Fst *, PyObject *, int __pyx_skip_dispatch); + std::string (*write_to_string)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch); +}; +static struct __pyx_vtabstruct_9pywrapfst__Fst *__pyx_vtabptr_9pywrapfst__Fst; + + +/* "pywrapfst.pyx":1774 + * + * + * cdef class _MutableFst(_Fst): # <<<<<<<<<<<<<< + * + * """ + */ + +struct __pyx_vtabstruct_9pywrapfst__MutableFst { + struct __pyx_vtabstruct_9pywrapfst__Fst __pyx_base; + void (*_check_mutating_imethod)(struct __pyx_obj_9pywrapfst__MutableFst *); + void (*_add_arc)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64, struct __pyx_obj_9pywrapfst_Arc *); + __pyx_t_10basictypes_int64 (*add_state)(struct __pyx_obj_9pywrapfst__MutableFst *, int __pyx_skip_dispatch); + void (*_arcsort)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__arcsort *__pyx_optional_args); + void (*_closure)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__closure *__pyx_optional_args); + void (*_concat)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst__Fst *); + void (*_connect)(struct __pyx_obj_9pywrapfst__MutableFst *); + void (*_decode)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst_EncodeMapper *); + void (*_delete_arcs)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64, struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_arcs *__pyx_optional_args); + void (*_delete_states)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_states *__pyx_optional_args); + void (*_encode)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst_EncodeMapper *); + void (*_invert)(struct __pyx_obj_9pywrapfst__MutableFst *); + void (*_minimize)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__minimize *__pyx_optional_args); + struct __pyx_obj_9pywrapfst_MutableArcIterator *(*mutable_arcs)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch); + __pyx_t_10basictypes_int64 (*num_states)(struct __pyx_obj_9pywrapfst__MutableFst *, int __pyx_skip_dispatch); + void (*_project)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__project *__pyx_optional_args); + void (*_prune)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__prune *__pyx_optional_args); + void (*_push)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__push *__pyx_optional_args); + void (*_relabel_pairs)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_pairs *__pyx_optional_args); + void (*_relabel_tables)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_tables *__pyx_optional_args); + void (*_reserve_arcs)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64, size_t); + void (*_reserve_states)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64); + void (*_reweight)(struct __pyx_obj_9pywrapfst__MutableFst *, PyObject *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__reweight *__pyx_optional_args); + void (*_rmepsilon)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__rmepsilon *__pyx_optional_args); + void (*_set_final)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64, struct __pyx_opt_args_9pywrapfst_11_MutableFst__set_final *__pyx_optional_args); + void (*_set_properties)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_uint64, __pyx_t_10basictypes_uint64); + void (*_set_start)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64); + void (*_set_input_symbols)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst__SymbolTable *); + void (*_set_output_symbols)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst__SymbolTable *); + void (*_topsort)(struct __pyx_obj_9pywrapfst__MutableFst *); + void (*_union)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst__Fst *); +}; +static struct __pyx_vtabstruct_9pywrapfst__MutableFst *__pyx_vtabptr_9pywrapfst__MutableFst; + + +/* "pywrapfst.pyx":2898 + * + * + * cdef class Arc(object): # <<<<<<<<<<<<<< + * + * """ + */ + +struct __pyx_vtabstruct_9pywrapfst_Arc { + struct __pyx_obj_9pywrapfst_Arc *(*copy)(struct __pyx_obj_9pywrapfst_Arc *, int __pyx_skip_dispatch); +}; +static struct __pyx_vtabstruct_9pywrapfst_Arc *__pyx_vtabptr_9pywrapfst_Arc; + + +/* "pywrapfst.pyx":2965 + * + * + * cdef class ArcIterator(object): # <<<<<<<<<<<<<< + * + * """ + */ + +struct __pyx_vtabstruct_9pywrapfst_ArcIterator { + bool (*done)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch); + __pyx_t_10basictypes_uint32 (*flags)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch); + void (*next)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch); + size_t (*position)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch); + void (*reset)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch); + void (*seek)(struct __pyx_obj_9pywrapfst_ArcIterator *, size_t, int __pyx_skip_dispatch); + void (*set_flags)(struct __pyx_obj_9pywrapfst_ArcIterator *, __pyx_t_10basictypes_uint32, __pyx_t_10basictypes_uint32, int __pyx_skip_dispatch); + PyObject *(*value)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch); +}; +static struct __pyx_vtabstruct_9pywrapfst_ArcIterator *__pyx_vtabptr_9pywrapfst_ArcIterator; + + +/* "pywrapfst.pyx":3076 + * + * + * cdef class MutableArcIterator(object): # <<<<<<<<<<<<<< + * + * """ + */ + +struct __pyx_vtabstruct_9pywrapfst_MutableArcIterator { + bool (*done)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch); + __pyx_t_10basictypes_uint32 (*flags)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch); + void (*next)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch); + size_t (*position)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch); + void (*reset)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch); + void (*seek)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, size_t, int __pyx_skip_dispatch); + void (*set_flags)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, __pyx_t_10basictypes_uint32, __pyx_t_10basictypes_uint32, int __pyx_skip_dispatch); + void (*set_value)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, struct __pyx_obj_9pywrapfst_Arc *, int __pyx_skip_dispatch); + PyObject *(*value)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch); +}; +static struct __pyx_vtabstruct_9pywrapfst_MutableArcIterator *__pyx_vtabptr_9pywrapfst_MutableArcIterator; + + +/* "pywrapfst.pyx":3190 + * + * + * cdef class StateIterator(object): # <<<<<<<<<<<<<< + * + * """ + */ + +struct __pyx_vtabstruct_9pywrapfst_StateIterator { + bool (*done)(struct __pyx_obj_9pywrapfst_StateIterator *, int __pyx_skip_dispatch); + void (*next)(struct __pyx_obj_9pywrapfst_StateIterator *, int __pyx_skip_dispatch); + void (*reset)(struct __pyx_obj_9pywrapfst_StateIterator *, int __pyx_skip_dispatch); + __pyx_t_10basictypes_int64 (*value)(struct __pyx_obj_9pywrapfst_StateIterator *, int __pyx_skip_dispatch); +}; +static struct __pyx_vtabstruct_9pywrapfst_StateIterator *__pyx_vtabptr_9pywrapfst_StateIterator; + + +/* "pywrapfst.pyx":4088 + * + * + * cdef class Compiler(object): # <<<<<<<<<<<<<< + * + * """ + */ + +struct __pyx_vtabstruct_9pywrapfst_Compiler { + struct __pyx_obj_9pywrapfst__Fst *(*compile)(struct __pyx_obj_9pywrapfst_Compiler *, int __pyx_skip_dispatch); + void (*write)(struct __pyx_obj_9pywrapfst_Compiler *, PyObject *, int __pyx_skip_dispatch); +}; +static struct __pyx_vtabstruct_9pywrapfst_Compiler *__pyx_vtabptr_9pywrapfst_Compiler; + + +/* "pywrapfst.pyx":4215 + * + * + * cdef class FarReader(object): # <<<<<<<<<<<<<< + * + * """ + */ + +struct __pyx_vtabstruct_9pywrapfst_FarReader { + std::string (*arc_type)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch); + bool (*done)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch); + bool (*error)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch); + std::string (*far_type)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch); + bool (*find)(struct __pyx_obj_9pywrapfst_FarReader *, PyObject *, int __pyx_skip_dispatch); + struct __pyx_obj_9pywrapfst__Fst *(*get_fst)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch); + std::string (*get_key)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch); + void (*next)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch); + void (*reset)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch); +}; +static struct __pyx_vtabstruct_9pywrapfst_FarReader *__pyx_vtabptr_9pywrapfst_FarReader; + + +/* "pywrapfst.pyx":4360 + * + * + * cdef class FarWriter(object): # <<<<<<<<<<<<<< + * + * """ + */ + +struct __pyx_vtabstruct_9pywrapfst_FarWriter { + std::string (*arc_type)(struct __pyx_obj_9pywrapfst_FarWriter *, int __pyx_skip_dispatch); + void (*close)(struct __pyx_obj_9pywrapfst_FarWriter *); + void (*add)(struct __pyx_obj_9pywrapfst_FarWriter *, PyObject *, struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch); + bool (*error)(struct __pyx_obj_9pywrapfst_FarWriter *, int __pyx_skip_dispatch); + std::string (*far_type)(struct __pyx_obj_9pywrapfst_FarWriter *, int __pyx_skip_dispatch); +}; +static struct __pyx_vtabstruct_9pywrapfst_FarWriter *__pyx_vtabptr_9pywrapfst_FarWriter; + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* PyCFunctionFastCall.proto */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +#else +#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +#endif + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs); +#else +#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) +#endif +#endif + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* GetModuleGlobalName.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* RaiseArgTupleInvalid.proto */ +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +/* PyObjectCallNoArg.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); +#else +#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) +#endif + +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +/* ArgTypeTest.proto */ +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + __Pyx__ArgTypeTest(obj, type, name, exact)) +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); + +/* WriteUnraisableException.proto */ +static void __Pyx_WriteUnraisable(const char *name, int clineno, + int lineno, const char *filename, + int full_traceback, int nogil); + +/* KeywordStringCheck.proto */ +static int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); + +/* SaveResetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +#else +#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) +#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) +#endif + +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* GetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* RaiseTooManyValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +/* RaiseNeedMoreValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +/* IterFinish.proto */ +static CYTHON_INLINE int __Pyx_IterFinish(void); + +/* UnpackItemEndCheck.proto */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); + +/* IterNext.proto */ +#define __Pyx_PyIter_Next(obj) __Pyx_PyIter_Next2(obj, NULL) +static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject *, PyObject *); + +/* ListCompAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len)) { + Py_INCREF(x); + PyList_SET_ITEM(list, len, x); + Py_SIZE(list) = len+1; + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) +#endif + +/* SetVTable.proto */ +static int __Pyx_SetVtable(PyObject *dict, void *vtable); + +/* SetupReduce.proto */ +static int __Pyx_setup_reduce(PyObject* type_obj); + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* CalculateMetaclass.proto */ +static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); + +/* Py3ClassCreate.proto */ +static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname, + PyObject *mkw, PyObject *modname, PyObject *doc); +static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, + PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass); + +/* GetNameInClass.proto */ +static PyObject *__Pyx_GetNameInClass(PyObject *nmspace, PyObject *name); + +/* ClassMethod.proto */ +#include "descrobject.h" +static PyObject* __Pyx_Method_ClassMethod(PyObject *method); + +/* FetchCommonType.proto */ +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); + +/* CythonFunction.proto */ +#define __Pyx_CyFunction_USED 1 +#include +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { + PyCFunctionObject func; +#if PY_VERSION_HEX < 0x030500A0 + PyObject *func_weakreflist; +#endif + PyObject *func_dict; + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; + PyObject *func_classobj; + void *defaults; + int defaults_pyobjects; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; +} __pyx_CyFunctionObject; +static PyTypeObject *__pyx_CyFunctionType = 0; +#define __Pyx_CyFunction_NewEx(ml, flags, qualname, self, module, globals, code)\ + __Pyx_CyFunction_New(__pyx_CyFunctionType, ml, flags, qualname, self, module, globals, code) +static PyObject *__Pyx_CyFunction_New(PyTypeObject *, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *self, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(void); + +/* CLineInTraceback.proto */ +#ifdef CYTHON_CLINE_IN_TRACEBACK +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) +#else +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); +#endif + +/* CodeObjectCache.proto */ +typedef struct { + PyCodeObject* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +/* None.proto */ +#include + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint64_t(uint64_t value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint32_t(uint32_t value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int64_t(int64_t value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int32_t(int32_t value); + +/* CppExceptionConversion.proto */ +#ifndef __Pyx_CppExn2PyErr +#include +#include +#include +#include +static void __Pyx_CppExn2PyErr() { + try { + if (PyErr_Occurred()) + ; // let the latest Python exn pass through and ignore the current one + else + throw; + } catch (const std::bad_alloc& exn) { + PyErr_SetString(PyExc_MemoryError, exn.what()); + } catch (const std::bad_cast& exn) { + PyErr_SetString(PyExc_TypeError, exn.what()); + } catch (const std::bad_typeid& exn) { + PyErr_SetString(PyExc_TypeError, exn.what()); + } catch (const std::domain_error& exn) { + PyErr_SetString(PyExc_ValueError, exn.what()); + } catch (const std::invalid_argument& exn) { + PyErr_SetString(PyExc_ValueError, exn.what()); + } catch (const std::ios_base::failure& exn) { + PyErr_SetString(PyExc_IOError, exn.what()); + } catch (const std::out_of_range& exn) { + PyErr_SetString(PyExc_IndexError, exn.what()); + } catch (const std::overflow_error& exn) { + PyErr_SetString(PyExc_OverflowError, exn.what()); + } catch (const std::range_error& exn) { + PyErr_SetString(PyExc_ArithmeticError, exn.what()); + } catch (const std::underflow_error& exn) { + PyErr_SetString(PyExc_ArithmeticError, exn.what()); + } catch (const std::exception& exn) { + PyErr_SetString(PyExc_RuntimeError, exn.what()); + } + catch (...) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown exception"); + } +} +#endif + +/* CIntFromPy.proto */ +static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int64_t __Pyx_PyInt_As_int64_t(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE uint64_t __Pyx_PyInt_As_uint64_t(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int32_t __Pyx_PyInt_As_int32_t(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE uint32_t __Pyx_PyInt_As_uint32_t(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE time_t __Pyx_PyInt_As_time_t(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +/* FastTypeChecks.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); +#else +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) +#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) +#endif + +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(void); + +/* FunctionExport.proto */ +static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig); + +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + +static void __pyx_f_9pywrapfst_6Weight__check_weight(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self); /* proto*/ +static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst_6Weight_copy(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static std::string __pyx_f_9pywrapfst_6Weight_to_string(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static std::string __pyx_f_9pywrapfst_6Weight_type(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_12_SymbolTable_available_key(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static std::string __pyx_f_9pywrapfst_12_SymbolTable_checksum(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst_12_SymbolTable_copy(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_12_SymbolTable_get_nth_key(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, Py_ssize_t __pyx_v_pos, int __pyx_skip_dispatch); /* proto*/ +static std::string __pyx_f_9pywrapfst_12_SymbolTable_labeled_checksum(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static bool __pyx_f_9pywrapfst_12_SymbolTable_member(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_key, int __pyx_skip_dispatch); /* proto*/ +static std::string __pyx_f_9pywrapfst_12_SymbolTable_name(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static size_t __pyx_f_9pywrapfst_12_SymbolTable_num_symbols(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_12_SymbolTable_write(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_filename, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_12_SymbolTable_write_text(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_filename, int __pyx_skip_dispatch); /* proto*/ +static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_19_MutableSymbolTable_add_symbol(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, PyObject *__pyx_v_symbol, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_19_MutableSymbolTable_add_symbol *__pyx_optional_args); /* proto*/ +static void __pyx_f_9pywrapfst_19_MutableSymbolTable_add_table(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_19_MutableSymbolTable_set_name(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, PyObject *__pyx_v_new_name, int __pyx_skip_dispatch); /* proto*/ +static bool __pyx_f_9pywrapfst_19SymbolTableIterator_done(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_19SymbolTableIterator_next(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_19SymbolTableIterator_reset(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static std::string __pyx_f_9pywrapfst_19SymbolTableIterator_symbol(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_19SymbolTableIterator_value(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static std::string __pyx_f_9pywrapfst_12EncodeMapper_arc_type(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static __pyx_t_10basictypes_uint32 __pyx_f_9pywrapfst_12EncodeMapper_flags(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_f_9pywrapfst_12EncodeMapper_input_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_f_9pywrapfst_12EncodeMapper_output_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static __pyx_t_10basictypes_uint64 __pyx_f_9pywrapfst_12EncodeMapper_properties(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_mask, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_12EncodeMapper_set_input_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_12EncodeMapper_set_output_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms, int __pyx_skip_dispatch); /* proto*/ +static std::string __pyx_f_9pywrapfst_12EncodeMapper_weight_type(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static std::string __pyx_f_9pywrapfst_4_Fst_arc_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_f_9pywrapfst_4_Fst_arcs(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch); /* proto*/ +static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst_4_Fst_copy(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_4_Fst_draw(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, PyObject *__pyx_v_filename, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_4_Fst_draw *__pyx_optional_args); /* proto*/ +static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst_4_Fst_final(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch); /* proto*/ +static std::string __pyx_f_9pywrapfst_4_Fst_fst_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_f_9pywrapfst_4_Fst_input_symbols(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static size_t __pyx_f_9pywrapfst_4_Fst_num_arcs(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch); /* proto*/ +static size_t __pyx_f_9pywrapfst_4_Fst_num_input_epsilons(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch); /* proto*/ +static size_t __pyx_f_9pywrapfst_4_Fst_num_output_epsilons(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch); /* proto*/ +static struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_f_9pywrapfst_4_Fst_output_symbols(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static __pyx_t_10basictypes_uint64 __pyx_f_9pywrapfst_4_Fst_properties(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_mask, bool __pyx_v_test, int __pyx_skip_dispatch); /* proto*/ +static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_4_Fst_start(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static struct __pyx_obj_9pywrapfst_StateIterator *__pyx_f_9pywrapfst_4_Fst_states(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static std::string __pyx_f_9pywrapfst_4_Fst_text(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_4_Fst_text *__pyx_optional_args); /* proto*/ +static bool __pyx_f_9pywrapfst_4_Fst_verify(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static std::string __pyx_f_9pywrapfst_4_Fst_weight_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_4_Fst_write(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, PyObject *__pyx_v_filename, int __pyx_skip_dispatch); /* proto*/ +static std::string __pyx_f_9pywrapfst_4_Fst_write_to_string(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__check_mutating_imethod(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__add_arc(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc); /* proto*/ +static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_11_MutableFst_add_state(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__arcsort(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__arcsort *__pyx_optional_args); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__closure(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__closure *__pyx_optional_args); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__concat(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__connect(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__decode(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_encoder); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__delete_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_arcs *__pyx_optional_args); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__delete_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_states *__pyx_optional_args); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__encode(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_encoder); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__invert(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__minimize(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__minimize *__pyx_optional_args); /* proto*/ +static struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_f_9pywrapfst_11_MutableFst_mutable_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch); /* proto*/ +static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_11_MutableFst_num_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__project(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__project *__pyx_optional_args); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__prune(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__prune *__pyx_optional_args); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__push(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__push *__pyx_optional_args); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__relabel_pairs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_pairs *__pyx_optional_args); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__relabel_tables(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_tables *__pyx_optional_args); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__reserve_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, size_t __pyx_v_n); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__reserve_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_n); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__reweight(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, PyObject *__pyx_v_potentials, struct __pyx_opt_args_9pywrapfst_11_MutableFst__reweight *__pyx_optional_args); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__rmepsilon(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__rmepsilon *__pyx_optional_args); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__set_final(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, struct __pyx_opt_args_9pywrapfst_11_MutableFst__set_final *__pyx_optional_args); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__set_input_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__set_output_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__set_properties(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_props, __pyx_t_10basictypes_uint64 __pyx_v_mask); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__set_start(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__topsort(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self); /* proto*/ +static void __pyx_f_9pywrapfst_11_MutableFst__union(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst); /* proto*/ +static struct __pyx_obj_9pywrapfst_Arc *__pyx_f_9pywrapfst_3Arc_copy(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static bool __pyx_f_9pywrapfst_11ArcIterator_done(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static __pyx_t_10basictypes_uint32 __pyx_f_9pywrapfst_11ArcIterator_flags(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_11ArcIterator_next(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static size_t __pyx_f_9pywrapfst_11ArcIterator_position(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_11ArcIterator_reset(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_11ArcIterator_seek(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, size_t __pyx_v_a, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_11ArcIterator_set_flags(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, __pyx_t_10basictypes_uint32 __pyx_v_flags, __pyx_t_10basictypes_uint32 __pyx_v_mask, int __pyx_skip_dispatch); /* proto*/ +static PyObject *__pyx_f_9pywrapfst_11ArcIterator_value(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static bool __pyx_f_9pywrapfst_18MutableArcIterator_done(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static __pyx_t_10basictypes_uint32 __pyx_f_9pywrapfst_18MutableArcIterator_flags(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_18MutableArcIterator_next(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static size_t __pyx_f_9pywrapfst_18MutableArcIterator_position(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_18MutableArcIterator_reset(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_18MutableArcIterator_seek(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, size_t __pyx_v_a, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_18MutableArcIterator_set_flags(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, __pyx_t_10basictypes_uint32 __pyx_v_flags, __pyx_t_10basictypes_uint32 __pyx_v_mask, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_18MutableArcIterator_set_value(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc, int __pyx_skip_dispatch); /* proto*/ +static PyObject *__pyx_f_9pywrapfst_18MutableArcIterator_value(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static bool __pyx_f_9pywrapfst_13StateIterator_done(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_13StateIterator_next(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_13StateIterator_reset(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_13StateIterator_value(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst_8Compiler_compile(struct __pyx_obj_9pywrapfst_Compiler *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_8Compiler_write(struct __pyx_obj_9pywrapfst_Compiler *__pyx_v_self, PyObject *__pyx_v_expression, int __pyx_skip_dispatch); /* proto*/ +static std::string __pyx_f_9pywrapfst_9FarReader_arc_type(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static bool __pyx_f_9pywrapfst_9FarReader_done(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static bool __pyx_f_9pywrapfst_9FarReader_error(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static std::string __pyx_f_9pywrapfst_9FarReader_far_type(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static bool __pyx_f_9pywrapfst_9FarReader_find(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, PyObject *__pyx_v_key, int __pyx_skip_dispatch); /* proto*/ +static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst_9FarReader_get_fst(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static std::string __pyx_f_9pywrapfst_9FarReader_get_key(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_9FarReader_next(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_9FarReader_reset(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static void __pyx_f_9pywrapfst_9FarWriter_close(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self); /* proto*/ +static void __pyx_f_9pywrapfst_9FarWriter_add(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, PyObject *__pyx_v_key, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, int __pyx_skip_dispatch); /* proto*/ +static std::string __pyx_f_9pywrapfst_9FarWriter_arc_type(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static bool __pyx_f_9pywrapfst_9FarWriter_error(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ +static std::string __pyx_f_9pywrapfst_9FarWriter_far_type(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ + +/* Module declarations from 'libc.stddef' */ + +/* Module declarations from 'libc.time' */ + +/* Module declarations from 'libcpp' */ + +/* Module declarations from 'libcpp.memory' */ + +/* Module declarations from 'libcpp.utility' */ + +/* Module declarations from 'libcpp.vector' */ + +/* Module declarations from 'libc.string' */ + +/* Module declarations from 'libcpp.string' */ + +/* Module declarations from 'libc.stdint' */ + +/* Module declarations from 'basictypes' */ + +/* Module declarations from 'ios' */ + +/* Module declarations from 'fst' */ + +/* Module declarations from 'posix.types' */ + +/* Module declarations from 'posix.unistd' */ + +/* Module declarations from 'libcpp.cast' */ + +/* Module declarations from 'memory' */ + +/* Module declarations from 'pywrapfst' */ +static PyTypeObject *__pyx_ptype_9pywrapfst_Weight = 0; +static PyTypeObject *__pyx_ptype_9pywrapfst__SymbolTable = 0; +static PyTypeObject *__pyx_ptype_9pywrapfst__EncodeMapperSymbolTable = 0; +static PyTypeObject *__pyx_ptype_9pywrapfst__FstSymbolTable = 0; +static PyTypeObject *__pyx_ptype_9pywrapfst__MutableSymbolTable = 0; +static PyTypeObject *__pyx_ptype_9pywrapfst__MutableFstSymbolTable = 0; +static PyTypeObject *__pyx_ptype_9pywrapfst_SymbolTable = 0; +static PyTypeObject *__pyx_ptype_9pywrapfst_SymbolTableIterator = 0; +static PyTypeObject *__pyx_ptype_9pywrapfst_EncodeMapper = 0; +static PyTypeObject *__pyx_ptype_9pywrapfst__Fst = 0; +static PyTypeObject *__pyx_ptype_9pywrapfst__MutableFst = 0; +static PyTypeObject *__pyx_ptype_9pywrapfst_Arc = 0; +static PyTypeObject *__pyx_ptype_9pywrapfst_ArcIterator = 0; +static PyTypeObject *__pyx_ptype_9pywrapfst_MutableArcIterator = 0; +static PyTypeObject *__pyx_ptype_9pywrapfst_StateIterator = 0; +static PyTypeObject *__pyx_ptype_9pywrapfst_Compiler = 0; +static PyTypeObject *__pyx_ptype_9pywrapfst_FarReader = 0; +static PyTypeObject *__pyx_ptype_9pywrapfst_FarWriter = 0; +static std::string __pyx_f_9pywrapfst_tostring(PyObject *, struct __pyx_opt_args_9pywrapfst_tostring *__pyx_optional_args); /*proto*/ +static std::string __pyx_f_9pywrapfst_weight_tostring(PyObject *, struct __pyx_opt_args_9pywrapfst_weight_tostring *__pyx_optional_args); /*proto*/ +static enum fst::ComposeFilter __pyx_f_9pywrapfst__get_compose_filter(std::string const &); /*proto*/ +static enum fst::QueueType __pyx_f_9pywrapfst__get_queue_type(std::string const &); /*proto*/ +static enum fst::script::RandArcSelection __pyx_f_9pywrapfst__get_rand_arc_selection(std::string const &); /*proto*/ +static enum fst::ReplaceLabelType __pyx_f_9pywrapfst__get_replace_label_type(std::string const &, bool); /*proto*/ +static fst::script::WeightClass __pyx_f_9pywrapfst__get_WeightClass_or_One(std::string const &, PyObject *); /*proto*/ +static fst::script::WeightClass __pyx_f_9pywrapfst__get_WeightClass_or_Zero(std::string const &, PyObject *); /*proto*/ +static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__Zero(PyObject *); /*proto*/ +static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__One(PyObject *); /*proto*/ +static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__NoWeight(PyObject *); /*proto*/ +static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__plus(struct __pyx_obj_9pywrapfst_Weight *, struct __pyx_obj_9pywrapfst_Weight *); /*proto*/ +static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__times(struct __pyx_obj_9pywrapfst_Weight *, struct __pyx_obj_9pywrapfst_Weight *); /*proto*/ +static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__divide(struct __pyx_obj_9pywrapfst_Weight *, struct __pyx_obj_9pywrapfst_Weight *); /*proto*/ +static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__power(struct __pyx_obj_9pywrapfst_Weight *, size_t); /*proto*/ +static struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_f_9pywrapfst__init_EncodeMapperSymbolTable(fst::SymbolTable *, std::shared_ptr ); /*proto*/ +static struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_f_9pywrapfst__init_FstSymbolTable(fst::SymbolTable *, std::shared_ptr ); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *__pyx_f_9pywrapfst__init_MutableFstSymbolTable(fst::SymbolTable *, std::shared_ptr ); /*proto*/ +static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst__init_SymbolTable(fst::SymbolTable *); /*proto*/ +static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst__init_Fst(__pyx_t_9pywrapfst_FstClass_ptr); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst__init_MutableFst(__pyx_t_9pywrapfst_MutableFstClass_ptr); /*proto*/ +static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst__init_XFst(__pyx_t_9pywrapfst_FstClass_ptr); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst__create_Fst(struct __pyx_opt_args_9pywrapfst__create_Fst *__pyx_optional_args); /*proto*/ +static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst__read(PyObject *, int __pyx_skip_dispatch); /*proto*/ +static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst__read_from_string(PyObject *, int __pyx_skip_dispatch); /*proto*/ +static struct __pyx_obj_9pywrapfst_Arc *__pyx_f_9pywrapfst__init_Arc(fst::script::ArcClass const &); /*proto*/ +static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst__map(struct __pyx_obj_9pywrapfst__Fst *, struct __pyx_opt_args_9pywrapfst__map *__pyx_optional_args); /*proto*/ +static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst_arcmap(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_arcmap *__pyx_optional_args); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_compose(struct __pyx_obj_9pywrapfst__Fst *, struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_compose *__pyx_optional_args); /*proto*/ +static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst_convert(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_convert *__pyx_optional_args); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_determinize(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_determinize *__pyx_optional_args); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_difference(struct __pyx_obj_9pywrapfst__Fst *, struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_difference *__pyx_optional_args); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_disambiguate(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_disambiguate *__pyx_optional_args); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_epsnormalize(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_epsnormalize *__pyx_optional_args); /*proto*/ +static bool __pyx_f_9pywrapfst_equal(struct __pyx_obj_9pywrapfst__Fst *, struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_equal *__pyx_optional_args); /*proto*/ +static bool __pyx_f_9pywrapfst_equivalent(struct __pyx_obj_9pywrapfst__Fst *, struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_equivalent *__pyx_optional_args); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_intersect(struct __pyx_obj_9pywrapfst__Fst *, struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_intersect *__pyx_optional_args); /*proto*/ +static bool __pyx_f_9pywrapfst_isomorphic(struct __pyx_obj_9pywrapfst__Fst *, struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_isomorphic *__pyx_optional_args); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_prune(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_prune *__pyx_optional_args); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_push(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_push *__pyx_optional_args); /*proto*/ +static bool __pyx_f_9pywrapfst_randequivalent(struct __pyx_obj_9pywrapfst__Fst *, struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_randequivalent *__pyx_optional_args); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_randgen(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_randgen *__pyx_optional_args); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_replace(PyObject *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_replace *__pyx_optional_args); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_reverse(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_reverse *__pyx_optional_args); /*proto*/ +static std::vector *__pyx_f_9pywrapfst__shortestdistance(struct __pyx_obj_9pywrapfst__Fst *, struct __pyx_opt_args_9pywrapfst__shortestdistance *__pyx_optional_args); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_shortestpath(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_shortestpath *__pyx_optional_args); /*proto*/ +static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst_statemap(struct __pyx_obj_9pywrapfst__Fst *, PyObject *, int __pyx_skip_dispatch); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_synchronize(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch); /*proto*/ +static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst_compact_symbol_table(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch); /*proto*/ +static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst_merge_symbol_table(struct __pyx_obj_9pywrapfst__SymbolTable *, struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch); /*proto*/ +static std::string __pyx_convert_string_from_py_std__in_string(PyObject *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_convert_PyObject_string_to_py_std__in_string(std::string const &); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_convert_PyUnicode_string_to_py_std__in_string(std::string const &); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_convert_PyStr_string_to_py_std__in_string(std::string const &); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_convert_PyBytes_string_to_py_std__in_string(std::string const &); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_convert_PyByteArray_string_to_py_std__in_string(std::string const &); /*proto*/ +static std::vector<__pyx_t_10basictypes_int64> __pyx_convert_vector_from_py___pyx_t_10basictypes_int64(PyObject *); /*proto*/ +static std::vector __pyx_convert_vector_from_py_std_3a__3a_string(PyObject *); /*proto*/ +#define __Pyx_MODULE_NAME "pywrapfst" +extern int __pyx_module_is_main_pywrapfst; +int __pyx_module_is_main_pywrapfst = 0; + +/* Implementation of 'pywrapfst' */ +static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_RuntimeError; +static PyObject *__pyx_builtin_IndexError; +static PyObject *__pyx_builtin_IOError; +static PyObject *__pyx_builtin_object; +static PyObject *__pyx_builtin_staticmethod; +static PyObject *__pyx_builtin_id; +static PyObject *__pyx_builtin_TypeError; +static PyObject *__pyx_builtin_StopIteration; +static PyObject *__pyx_builtin_KeyError; +static const char __pyx_k_g[] = "g"; +static const char __pyx_k_n[] = "n"; +static const char __pyx_k_w[] = "w"; +static const char __pyx_k_id[] = "id"; +static const char __pyx_k_Fst[] = "Fst"; +static const char __pyx_k_One[] = "One"; +static const char __pyx_k__24[] = ""; +static const char __pyx_k_add[] = "add"; +static const char __pyx_k_arc[] = "arc"; +static const char __pyx_k_cls[] = "cls"; +static const char __pyx_k_doc[] = "__doc__"; +static const char __pyx_k_dot[] = "dot"; +static const char __pyx_k_key[] = "key"; +static const char __pyx_k_lhs[] = "lhs"; +static const char __pyx_k_new[] = "__new__"; +static const char __pyx_k_rhs[] = "rhs"; +static const char __pyx_k_PIPE[] = "PIPE"; +static const char __pyx_k_Tsvg[] = "-Tsvg"; +static const char __pyx_k_Zero[] = "Zero"; +static const char __pyx_k_arcs[] = "arcs"; +static const char __pyx_k_auto[] = "auto"; +static const char __pyx_k_copy[] = "copy"; +static const char __pyx_k_done[] = "done"; +static const char __pyx_k_draw[] = "draw"; +static const char __pyx_k_find[] = "find"; +static const char __pyx_k_ifst[] = "ifst"; +static const char __pyx_k_main[] = "__main__"; +static const char __pyx_k_mask[] = "mask"; +static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_next[] = "next"; +static const char __pyx_k_open[] = "open"; +static const char __pyx_k_plus[] = "plus"; +static const char __pyx_k_read[] = "read"; +static const char __pyx_k_seed[] = "seed"; +static const char __pyx_k_seek[] = "seek"; +static const char __pyx_k_syms[] = "syms"; +static const char __pyx_k_test[] = "test"; +static const char __pyx_k_text[] = "text"; +static const char __pyx_k_type[] = "type"; +static const char __pyx_k_utf8[] = "utf8"; +static const char __pyx_k_ERROR[] = "ERROR"; +static const char __pyx_k_Popen[] = "Popen"; +static const char __pyx_k_class[] = "__class__"; +static const char __pyx_k_delta[] = "delta"; +static const char __pyx_k_error[] = "error"; +static const char __pyx_k_final[] = "final"; +static const char __pyx_k_flags[] = "flags"; +static const char __pyx_k_ifst1[] = "ifst1"; +static const char __pyx_k_ifst2[] = "ifst2"; +static const char __pyx_k_input[] = "input"; +static const char __pyx_k_npath[] = "npath"; +static const char __pyx_k_pairs[] = "pairs"; +static const char __pyx_k_power[] = "power"; +static const char __pyx_k_props[] = "props"; +static const char __pyx_k_reset[] = "reset"; +static const char __pyx_k_start[] = "start"; +static const char __pyx_k_state[] = "state"; +static const char __pyx_k_stdin[] = "stdin"; +static const char __pyx_k_times[] = "times"; +static const char __pyx_k_title[] = "title"; +static const char __pyx_k_value[] = "value"; +static const char __pyx_k_width[] = "width"; +static const char __pyx_k_write[] = "write"; +static const char __pyx_k_CYCLIC[] = "CYCLIC"; +static const char __pyx_k_Number[] = "Number"; +static const char __pyx_k_STRING[] = "STRING"; +static const char __pyx_k_atexit[] = "atexit"; +static const char __pyx_k_create[] = "create"; +static const char __pyx_k_decode[] = "decode"; +static const char __pyx_k_divide[] = "divide"; +static const char __pyx_k_encode[] = "encode"; +static const char __pyx_k_format[] = "format"; +static const char __pyx_k_height[] = "height"; +static const char __pyx_k_ilabel[] = "ilabel"; +static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_ipairs[] = "ipairs"; +static const char __pyx_k_member[] = "member"; +static const char __pyx_k_module[] = "__module__"; +static const char __pyx_k_name_2[] = "name"; +static const char __pyx_k_nstate[] = "nstate"; +static const char __pyx_k_object[] = "object"; +static const char __pyx_k_olabel[] = "olabel"; +static const char __pyx_k_opairs[] = "opairs"; +static const char __pyx_k_reduce[] = "__reduce__"; +static const char __pyx_k_result[] = "result"; +static const char __pyx_k_select[] = "select"; +static const char __pyx_k_states[] = "states"; +static const char __pyx_k_stderr[] = "stderr"; +static const char __pyx_k_stdout[] = "stdout"; +static const char __pyx_k_symbol[] = "symbol"; +static const char __pyx_k_test_2[] = "__test__"; +static const char __pyx_k_unique[] = "unique"; +static const char __pyx_k_vector[] = "vector"; +static const char __pyx_k_verify[] = "verify"; +static const char __pyx_k_weight[] = "weight"; +static const char __pyx_k_ACYCLIC[] = "ACYCLIC"; +static const char __pyx_k_IOError[] = "IOError"; +static const char __pyx_k_MUTABLE[] = "MUTABLE"; +static const char __pyx_k_compile[] = "compile"; +static const char __pyx_k_connect[] = "connect"; +static const char __pyx_k_default[] = "default"; +static const char __pyx_k_get_fst[] = "get_fst"; +static const char __pyx_k_get_key[] = "get_key"; +static const char __pyx_k_logging[] = "logging"; +static const char __pyx_k_neither[] = "neither"; +static const char __pyx_k_nodesep[] = "nodesep"; +static const char __pyx_k_numbers[] = "numbers"; +static const char __pyx_k_prepare[] = "__prepare__"; +static const char __pyx_k_ranksep[] = "ranksep"; +static const char __pyx_k_reverse[] = "reverse"; +static const char __pyx_k_uniform[] = "uniform"; +static const char __pyx_k_warning[] = "warning"; +static const char __pyx_k_ACCEPTOR[] = "ACCEPTOR"; +static const char __pyx_k_DOT_TSVG[] = "_DOT_TSVG"; +static const char __pyx_k_EPSILONS[] = "EPSILONS"; +static const char __pyx_k_EXPANDED[] = "EXPANDED"; +static const char __pyx_k_FstError[] = "FstError"; +static const char __pyx_k_Fst_read[] = "Fst.read"; +static const char __pyx_k_KeyError[] = "KeyError"; +static const char __pyx_k_NO_LABEL[] = "NO_LABEL"; +static const char __pyx_k_NoWeight[] = "NoWeight"; +static const char __pyx_k_WEIGHTED[] = "WEIGHTED"; +static const char __pyx_k_acceptor[] = "acceptor"; +static const char __pyx_k_arc_type[] = "arc_type"; +static const char __pyx_k_checksum[] = "checksum"; +static const char __pyx_k_det_type[] = "det_type"; +static const char __pyx_k_distance[] = "distance"; +static const char __pyx_k_far_type[] = "far_type"; +static const char __pyx_k_filename[] = "filename"; +static const char __pyx_k_fontsize[] = "fontsize"; +static const char __pyx_k_fst_type[] = "fst_type"; +static const char __pyx_k_getstate[] = "__getstate__"; +static const char __pyx_k_identity[] = "identity"; +static const char __pyx_k_isymbols[] = "isymbols"; +static const char __pyx_k_map_type[] = "map_type"; +static const char __pyx_k_num_arcs[] = "num_arcs"; +static const char __pyx_k_osymbols[] = "osymbols"; +static const char __pyx_k_portrait[] = "portrait"; +static const char __pyx_k_position[] = "position"; +static const char __pyx_k_qualname[] = "__qualname__"; +static const char __pyx_k_read_fst[] = "read_fst"; +static const char __pyx_k_register[] = "register"; +static const char __pyx_k_repr_svg[] = "_repr_svg"; +static const char __pyx_k_set_name[] = "set_name"; +static const char __pyx_k_setstate[] = "__setstate__"; +static const char __pyx_k_ssymbols[] = "ssymbols"; +static const char __pyx_k_standard[] = "standard"; +static const char __pyx_k_to_final[] = "to_final"; +static const char __pyx_k_tropical[] = "tropical"; +static const char __pyx_k_vertical[] = "vertical"; +static const char __pyx_k_weighted[] = "weighted"; +static const char __pyx_k_ARC_FLAGS[] = "ARC_FLAGS"; +static const char __pyx_k_Fst___new[] = "Fst.__new__"; +static const char __pyx_k_NO_SYMBOL[] = "NO_SYMBOL"; +static const char __pyx_k_TypeError[] = "TypeError"; +static const char __pyx_k_add_state[] = "add_state"; +static const char __pyx_k_add_table[] = "add_table"; +static const char __pyx_k_kNoSymbol[] = "kNoSymbol"; +static const char __pyx_k_metaclass[] = "__metaclass__"; +static const char __pyx_k_nextstate[] = "nextstate"; +static const char __pyx_k_nshortest[] = "nshortest"; +static const char __pyx_k_precision[] = "precision"; +static const char __pyx_k_pywrapfst[] = ""; +static const char __pyx_k_read_text[] = "read_text"; +static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; +static const char __pyx_k_set_flags[] = "set_flags"; +static const char __pyx_k_set_value[] = "set_value"; +static const char __pyx_k_sort_type[] = "sort_type"; +static const char __pyx_k_to_string[] = "to_string"; +static const char __pyx_k_ACCESSIBLE[] = "ACCESSIBLE"; +static const char __pyx_k_FstIOError[] = "FstIOError"; +static const char __pyx_k_FstOpError[] = "FstOpError"; +static const char __pyx_k_I_EPSILONS[] = "I_EPSILONS"; +static const char __pyx_k_IndexError[] = "IndexError"; +static const char __pyx_k_NOT_STRING[] = "NOT_STRING"; +static const char __pyx_k_O_EPSILONS[] = "O_EPSILONS"; +static const char __pyx_k_TOP_SORTED[] = "TOP_SORTED"; +static const char __pyx_k_UNWEIGHTED[] = "UNWEIGHTED"; +static const char __pyx_k_ValueError[] = "ValueError"; +static const char __pyx_k_add_symbol[] = "add_symbol"; +static const char __pyx_k_functional[] = "functional"; +static const char __pyx_k_max_length[] = "max_length"; +static const char __pyx_k_num_states[] = "num_states"; +static const char __pyx_k_potentials[] = "potentials"; +static const char __pyx_k_properties[] = "properties"; +static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; +static const char __pyx_k_queue_type[] = "queue_type"; +static const char __pyx_k_returncode[] = "returncode"; +static const char __pyx_k_subprocess[] = "subprocess"; +static const char __pyx_k_write_text[] = "write_text"; +static const char __pyx_k_Arc_at_0x_x[] = ""; +static const char __pyx_k_FstArgError[] = "FstArgError"; +static const char __pyx_k_Fst_at_0x_x[] = "<{} Fst at 0x{:x}>"; +static const char __pyx_k_NO_EPSILONS[] = "NO_EPSILONS"; +static const char __pyx_k_NO_STATE_ID[] = "NO_STATE_ID"; +static const char __pyx_k_communicate[] = "communicate"; +static const char __pyx_k_get_nth_key[] = "get_nth_key"; +static const char __pyx_k_input_table[] = "input_table"; +static const char __pyx_k_missing_sym[] = "missing_sym"; +static const char __pyx_k_num_symbols[] = "num_symbols"; +static const char __pyx_k_push_labels[] = "push_labels"; +static const char __pyx_k_pywrapfst_2[] = "pywrapfst"; +static const char __pyx_k_unspecified[] = ""; +static const char __pyx_k_weight_type[] = "weight_type"; +static const char __pyx_k_ARC_NO_CACHE[] = "ARC_NO_CACHE"; +static const char __pyx_k_COACCESSIBLE[] = "COACCESSIBLE"; +static const char __pyx_k_ENCODE_FLAGS[] = "ENCODE_FLAGS"; +static const char __pyx_k_NOT_ACCEPTOR[] = "NOT_ACCEPTOR"; +static const char __pyx_k_RuntimeError[] = "RuntimeError"; +static const char __pyx_k_allow_nondet[] = "allow_nondet"; +static const char __pyx_k_closure_plus[] = "closure_plus"; +static const char __pyx_k_float_format[] = "float_format"; +static const char __pyx_k_mutable_arcs[] = "mutable_arcs"; +static const char __pyx_k_new_isymbols[] = "new_isymbols"; +static const char __pyx_k_new_osymbols[] = "new_osymbols"; +static const char __pyx_k_old_isymbols[] = "old_isymbols"; +static const char __pyx_k_old_osymbols[] = "old_osymbols"; +static const char __pyx_k_push_weights[] = "push_weights"; +static const char __pyx_k_return_label[] = "return_label"; +static const char __pyx_k_staticmethod[] = "staticmethod"; +static const char __pyx_k_ENCODE_LABELS[] = "ENCODE_LABELS"; +static const char __pyx_k_FstIndexError[] = "FstIndexError"; +static const char __pyx_k_NO_I_EPSILONS[] = "NO_I_EPSILONS"; +static const char __pyx_k_NO_O_EPSILONS[] = "NO_O_EPSILONS"; +static const char __pyx_k_Open_failed_r[] = "Open failed: {!r}"; +static const char __pyx_k_Read_failed_r[] = "Read failed: {!r}"; +static const char __pyx_k_StopIteration[] = "StopIteration"; +static const char __pyx_k_available_key[] = "available_key"; +static const char __pyx_k_encode_labels[] = "encode_labels"; +static const char __pyx_k_input_symbols[] = "input_symbols"; +static const char __pyx_k_keep_isymbols[] = "keep_isymbols"; +static const char __pyx_k_keep_osymbols[] = "keep_osymbols"; +static const char __pyx_k_pywrapfst_pyx[] = "pywrapfst.pyx"; +static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; +static const char __pyx_k_ENCODE_WEIGHTS[] = "ENCODE_WEIGHTS"; +static const char __pyx_k_FST_PROPERTIES[] = "FST_PROPERTIES"; +static const char __pyx_k_INITIAL_CYCLIC[] = "INITIAL_CYCLIC"; +static const char __pyx_k_I_LABEL_SORTED[] = "I_LABEL_SORTED"; +static const char __pyx_k_Invalid_weight[] = "Invalid weight"; +static const char __pyx_k_NOT_ACCESSIBLE[] = "NOT_ACCESSIBLE"; +static const char __pyx_k_NOT_TOP_SORTED[] = "NOT_TOP_SORTED"; +static const char __pyx_k_O_LABEL_SORTED[] = "O_LABEL_SORTED"; +static const char __pyx_k_Weight_at_0x_x[] = "<{} Weight {} at 0x{:x}>"; +static const char __pyx_k_Write_failed_r[] = "Write failed: {!r}"; +static const char __pyx_k_compose_filter[] = "compose_filter"; +static const char __pyx_k_encode_weights[] = "encode_weights"; +static const char __pyx_k_output_symbols[] = "output_symbols"; +static const char __pyx_k_project_output[] = "project_output"; +static const char __pyx_k_ARC_VALUE_FLAGS[] = "ARC_VALUE_FLAGS"; +static const char __pyx_k_COPY_PROPERTIES[] = "COPY_PROPERTIES"; +static const char __pyx_k_INITIAL_ACYCLIC[] = "INITIAL_ACYCLIC"; +static const char __pyx_k_I_DETERMINISTIC[] = "I_DETERMINISTIC"; +static const char __pyx_k_NULL_PROPERTIES[] = "NULL_PROPERTIES"; +static const char __pyx_k_O_DETERMINISTIC[] = "O_DETERMINISTIC"; +static const char __pyx_k_WEIGHTED_CYCLES[] = "WEIGHTED_CYCLES"; +static const char __pyx_k_eps_norm_output[] = "eps_norm_output"; +static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; +static const char __pyx_k_show_weight_one[] = "show_weight_one"; +static const char __pyx_k_unknown_isymbol[] = "unknown_isymbol"; +static const char __pyx_k_unknown_osymbol[] = "unknown_osymbol"; +static const char __pyx_k_write_to_string[] = "write_to_string"; +static const char __pyx_k_ARC_WEIGHT_VALUE[] = "ARC_WEIGHT_VALUE"; +static const char __pyx_k_Cannot_construct[] = "Cannot construct {}"; +static const char __pyx_k_Key_out_of_order[] = "Key out of order"; +static const char __pyx_k_NOT_COACCESSIBLE[] = "NOT_COACCESSIBLE"; +static const char __pyx_k_Operation_failed[] = "Operation failed"; +static const char __pyx_k_labeled_checksum[] = "labeled_checksum"; +static const char __pyx_k_read_from_string[] = "_read_from_string"; +static const char __pyx_k_shortestdistance[] = "shortestdistance"; +static const char __pyx_k_ARC_I_LABEL_VALUE[] = "ARC_I_LABEL_VALUE"; +static const char __pyx_k_ARC_O_LABEL_VALUE[] = "ARC_O_LABEL_VALUE"; +static const char __pyx_k_BINARY_PROPERTIES[] = "BINARY_PROPERTIES"; +static const char __pyx_k_FarReader_at_0x_x[] = "<{} FarReader at 0x{:x}>"; +static const char __pyx_k_FarWriter_at_0x_x[] = "<{} FarWriter at 0x{:x}>"; +static const char __pyx_k_FstBadWeightError[] = "FstBadWeightError"; +static const char __pyx_k_UNWEIGHTED_CYCLES[] = "UNWEIGHTED_CYCLES"; +static const char __pyx_k_call_arc_labeling[] = "call_arc_labeling"; +static const char __pyx_k_set_input_symbols[] = "set_input_symbols"; +static const char __pyx_k_ADD_ARC_PROPERTIES[] = "ADD_ARC_PROPERTIES"; +static const char __pyx_k_CalledProcessError[] = "CalledProcessError"; +static const char __pyx_k_Compilation_failed[] = "Compilation failed"; +static const char __pyx_k_NOT_I_LABEL_SORTED[] = "NOT_I_LABEL_SORTED"; +static const char __pyx_k_NOT_O_LABEL_SORTED[] = "NOT_O_LABEL_SORTED"; +static const char __pyx_k_Read_failed_string[] = "Read failed: "; +static const char __pyx_k_SET_ARC_PROPERTIES[] = "SET_ARC_PROPERTIES"; +static const char __pyx_k_TRINARY_PROPERTIES[] = "TRINARY_PROPERTIES"; +static const char __pyx_k_Unknown_arc_type_r[] = "Unknown arc type: {!r}"; +static const char __pyx_k_Unknown_map_type_r[] = "Unknown map type: {!r}"; +static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_epsilon_on_replace[] = "epsilon_on_replace"; +static const char __pyx_k_num_input_epsilons[] = "num_input_epsilons"; +static const char __pyx_k_read_from_string_2[] = "read_from_string"; +static const char __pyx_k_set_output_symbols[] = "set_output_symbols"; +static const char __pyx_k_ARC_SORT_PROPERTIES[] = "ARC_SORT_PROPERTIES"; +static const char __pyx_k_ArcIterator_at_0x_x[] = ""; +static const char __pyx_k_NON_I_DETERMINISTIC[] = "NON_I_DETERMINISTIC"; +static const char __pyx_k_NON_O_DETERMINISTIC[] = "NON_O_DETERMINISTIC"; +static const char __pyx_k_Unknown_sort_type_r[] = "Unknown sort type {!r}"; +static const char __pyx_k_attach_new_isymbols[] = "attach_new_isymbols"; +static const char __pyx_k_attach_new_osymbols[] = "attach_new_osymbols"; +static const char __pyx_k_fst_error_fatal_old[] = "_fst_error_fatal_old"; +static const char __pyx_k_num_output_epsilons[] = "num_output_epsilons"; +static const char __pyx_k_remove_common_affix[] = "remove_common_affix"; +static const char __pyx_k_remove_total_weight[] = "remove_total_weight"; +static const char __pyx_k_return_arc_labeling[] = "return_arc_labeling"; +static const char __pyx_k_subsequential_label[] = "subsequential_label"; +static const char __pyx_k_ADD_STATE_PROPERTIES[] = "ADD_STATE_PROPERTIES"; +static const char __pyx_k_ARC_NEXT_STATE_VALUE[] = "ARC_NEXT_STATE_VALUE"; +static const char __pyx_k_EXTRINSIC_PROPERTIES[] = "EXTRINSIC_PROPERTIES"; +static const char __pyx_k_EncodeMapper_at_0x_x[] = ""; +static const char __pyx_k_Fst_read_from_string[] = "Fst.read_from_string"; +static const char __pyx_k_INTRINSIC_PROPERTIES[] = "INTRINSIC_PROPERTIES"; +static const char __pyx_k_SET_FINAL_PROPERTIES[] = "SET_FINAL_PROPERTIES"; +static const char __pyx_k_SET_START_PROPERTIES[] = "SET_START_PROPERTIES"; +static const char __pyx_k_Unknown_queue_type_r[] = "Unknown queue type: {!r}"; +static const char __pyx_k_keep_state_numbering[] = "keep_state_numbering"; +static const char __pyx_k_require_superinitial[] = "require_superinitial"; +static const char __pyx_k_DELETE_ARC_PROPERTIES[] = "DELETE_ARC_PROPERTIES"; +static const char __pyx_k_STATE_SORT_PROPERTIES[] = "STATE_SORT_PROPERTIES"; +static const char __pyx_k_StateIterator_at_0x_x[] = ""; +static const char __pyx_k_SymbolTable_r_at_0x_x[] = ""; +static const char __pyx_k_Weight_type_not_found[] = "Weight type not found"; +static const char __pyx_k_allow_negative_labels[] = "allow_negative_labels"; +static const char __pyx_k_reset_fst_error_fatal[] = "_reset_fst_error_fatal"; +static const char __pyx_k_Conversion_to_r_failed[] = "Conversion to {!r} failed"; +static const char __pyx_k_NEG_TRINARY_PROPERTIES[] = "NEG_TRINARY_PROPERTIES"; +static const char __pyx_k_POS_TRINARY_PROPERTIES[] = "POS_TRINARY_PROPERTIES"; +static const char __pyx_k_Write_to_string_failed[] = "Write to string failed"; +static const char __pyx_k_DELETE_STATE_PROPERTIES[] = "DELETE_STATE_PROPERTIES"; +static const char __pyx_k_RM_SUPERFINAL_PROPERTIES[] = "RM_SUPERFINAL_PROPERTIES"; +static const char __pyx_k_State_index_out_of_range[] = "State index out of range"; +static const char __pyx_k_ADD_SUPERFINAL_PROPERTIES[] = "ADD_SUPERFINAL_PROPERTIES"; +static const char __pyx_k_Cannot_encode_as_string_r[] = "Cannot encode as string: {!r}"; +static const char __pyx_k_Cannot_topsort_cyclic_FST[] = "Cannot topsort cyclic FST."; +static const char __pyx_k_Fst_SymbolTable_r_at_0x_x[] = ""; +static const char __pyx_k_FstDeletedConstructorError[] = "FstDeletedConstructorError"; +static const char __pyx_k_MutableArcIterator_at_0x_x[] = ""; +static const char __pyx_k_SymbolTableIterator_at_0x_x[] = ""; +static const char __pyx_k_WEIGHT_INVARIANT_PROPERTIES[] = "WEIGHT_INVARIANT_PROPERTIES"; +static const char __pyx_k_I_LABEL_INVARIANT_PROPERTIES[] = "I_LABEL_INVARIANT_PROPERTIES"; +static const char __pyx_k_O_LABEL_INVARIANT_PROPERTIES[] = "O_LABEL_INVARIANT_PROPERTIES"; +static const char __pyx_k_Unknown_replace_label_type_r[] = "Unknown replace label type: {!r}"; +static const char __pyx_k_No_new_SymbolTables_specified[] = "No new SymbolTables specified"; +static const char __pyx_k_No_relabeling_pairs_specified[] = "No relabeling pairs specified."; +static const char __pyx_k_Unknown_compose_filter_type_r[] = "Unknown compose filter type: {!r}"; +static const char __pyx_k_increment_subsequential_label[] = "increment_subsequential_label"; +static const char __pyx_k_Incompatible_or_invalid_weight[] = "Incompatible or invalid weight"; +static const char __pyx_k_Unknown_determinization_type_r[] = "Unknown determinization type: {!r}"; +static const char __pyx_k_const_EncodeMapper_SymbolTable[] = ""; +static const char __pyx_k_Fst_arc_type_standard_Construct[] = "\n Fst(arc_type=\"standard\")\n\n Constructs an empty FST.\n\n Args:\n arc_type: A string indicating the arc type.\n\n Raises:\n FstError: Unknown arc type.\n\n Raises:\n FstOpError: operation failed.\n "; +static const char __pyx_k_const_Fst_SymbolTable_r_at_0x_x[] = ""; +static const char __pyx_k_self__aiter_self__fst_cannot_be[] = "self._aiter,self._fst cannot be converted to a Python object for pickling"; +static const char __pyx_k_self__fst_self__siter_cannot_be[] = "self._fst,self._siter cannot be converted to a Python object for pickling"; +static const char __pyx_k_self__fst_self__table_cannot_be[] = "self._fst,self._table cannot be converted to a Python object for pickling"; +static const char __pyx_k_self__table_cannot_be_converted[] = "self._table cannot be converted to a Python object for pickling"; +static const char __pyx_k_Incompatible_or_invalid_arc_type[] = "Incompatible or invalid arc type"; +static const char __pyx_k_Incompatible_or_invalid_weight_t[] = "Incompatible or invalid weight type"; +static const char __pyx_k_Python_interface_to_the_FST_scri[] = "Python interface to the FST scripting API.\n\nOperations which construct new FSTs are implemented as traditional functions, as\nare two-argument boolean functions like `equal` and `equivalent`. Destructive\noperations---those that mutate an FST, in place---are instance methods, as is\n`write`. Operator overloading is not used. The following example, based on\nMohri et al. 2002, shows the construction of an ASR system given a pronunciation\nlexicon L, grammar G, a transducer from context-dependent phones to\ncontext-independent phones C, and an HMM set H:\n\n L = fst.Fst.read(\"L.fst\")\n G = fst.Fst.read(\"G.fst\")\n C = fst.Fst.read(\"C.fst\")\n H = fst.Fst.read(\"H.fst\")\n LG = fst.determinize(fst.compose(L, G))\n CLG = fst.determinize(fst.compose(C, LG))\n HCLG = fst.determinize(fst.compose(H, CLG))\n HCLG.minimize() # NB: works in-place.\n\nPython variables here use snake_case and constants are in all caps, minus the\nnormal `k` prefix.\n"; +static const char __pyx_k_Unknown_random_arc_selection_typ[] = "Unknown random arc selection type: {!r}"; +static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; +static const char __pyx_k_self__aiter_self__mfst_cannot_be[] = "self._aiter,self._mfst cannot be converted to a Python object for pickling"; +static const char __pyx_k_self__arc_cannot_be_converted_to[] = "self._arc cannot be converted to a Python object for pickling"; +static const char __pyx_k_self__encoder_cannot_be_converte[] = "self._encoder cannot be converted to a Python object for pickling"; +static const char __pyx_k_self__encoder_self__table_cannot[] = "self._encoder,self._table cannot be converted to a Python object for pickling"; +static const char __pyx_k_self__mfst_self__table_cannot_be[] = "self._mfst,self._table cannot be converted to a Python object for pickling"; +static const char __pyx_k_self__reader_cannot_be_converted[] = "self._reader cannot be converted to a Python object for pickling"; +static const char __pyx_k_self__siter_self__table_cannot_b[] = "self._siter,self._table cannot be converted to a Python object for pickling"; +static const char __pyx_k_self__smart_table_self__table_ca[] = "self._smart_table,self._table cannot be converted to a Python object for pickling"; +static const char __pyx_k_self__weight_cannot_be_converted[] = "self._weight cannot be converted to a Python object for pickling"; +static const char __pyx_k_self__writer_cannot_be_converted[] = "self._writer cannot be converted to a Python object for pickling"; +static PyObject *__pyx_n_s_ACCEPTOR; +static PyObject *__pyx_n_s_ACCESSIBLE; +static PyObject *__pyx_n_s_ACYCLIC; +static PyObject *__pyx_n_s_ADD_ARC_PROPERTIES; +static PyObject *__pyx_n_s_ADD_STATE_PROPERTIES; +static PyObject *__pyx_n_s_ADD_SUPERFINAL_PROPERTIES; +static PyObject *__pyx_n_s_ARC_FLAGS; +static PyObject *__pyx_n_s_ARC_I_LABEL_VALUE; +static PyObject *__pyx_n_s_ARC_NEXT_STATE_VALUE; +static PyObject *__pyx_n_s_ARC_NO_CACHE; +static PyObject *__pyx_n_s_ARC_O_LABEL_VALUE; +static PyObject *__pyx_n_s_ARC_SORT_PROPERTIES; +static PyObject *__pyx_n_s_ARC_VALUE_FLAGS; +static PyObject *__pyx_n_s_ARC_WEIGHT_VALUE; +static PyObject *__pyx_kp_s_ArcIterator_at_0x_x; +static PyObject *__pyx_kp_s_Arc_at_0x_x; +static PyObject *__pyx_n_s_BINARY_PROPERTIES; +static PyObject *__pyx_n_s_COACCESSIBLE; +static PyObject *__pyx_n_s_COPY_PROPERTIES; +static PyObject *__pyx_n_s_CYCLIC; +static PyObject *__pyx_n_s_CalledProcessError; +static PyObject *__pyx_kp_s_Cannot_construct; +static PyObject *__pyx_kp_s_Cannot_encode_as_string_r; +static PyObject *__pyx_kp_s_Cannot_topsort_cyclic_FST; +static PyObject *__pyx_kp_s_Compilation_failed; +static PyObject *__pyx_kp_s_Conversion_to_r_failed; +static PyObject *__pyx_n_s_DELETE_ARC_PROPERTIES; +static PyObject *__pyx_n_s_DELETE_STATE_PROPERTIES; +static PyObject *__pyx_n_s_DOT_TSVG; +static PyObject *__pyx_n_s_ENCODE_FLAGS; +static PyObject *__pyx_n_s_ENCODE_LABELS; +static PyObject *__pyx_n_s_ENCODE_WEIGHTS; +static PyObject *__pyx_n_s_EPSILONS; +static PyObject *__pyx_n_s_ERROR; +static PyObject *__pyx_n_s_EXPANDED; +static PyObject *__pyx_n_s_EXTRINSIC_PROPERTIES; +static PyObject *__pyx_kp_s_EncodeMapper_at_0x_x; +static PyObject *__pyx_n_s_FST_PROPERTIES; +static PyObject *__pyx_kp_s_FarReader_at_0x_x; +static PyObject *__pyx_kp_s_FarWriter_at_0x_x; +static PyObject *__pyx_n_s_Fst; +static PyObject *__pyx_n_s_FstArgError; +static PyObject *__pyx_n_s_FstBadWeightError; +static PyObject *__pyx_n_s_FstDeletedConstructorError; +static PyObject *__pyx_n_s_FstError; +static PyObject *__pyx_n_s_FstIOError; +static PyObject *__pyx_n_s_FstIndexError; +static PyObject *__pyx_n_s_FstOpError; +static PyObject *__pyx_kp_s_Fst_SymbolTable_r_at_0x_x; +static PyObject *__pyx_n_s_Fst___new; +static PyObject *__pyx_kp_s_Fst_arc_type_standard_Construct; +static PyObject *__pyx_kp_s_Fst_at_0x_x; +static PyObject *__pyx_n_s_Fst_read; +static PyObject *__pyx_n_s_Fst_read_from_string; +static PyObject *__pyx_n_s_INITIAL_ACYCLIC; +static PyObject *__pyx_n_s_INITIAL_CYCLIC; +static PyObject *__pyx_n_s_INTRINSIC_PROPERTIES; +static PyObject *__pyx_n_s_IOError; +static PyObject *__pyx_n_s_I_DETERMINISTIC; +static PyObject *__pyx_n_s_I_EPSILONS; +static PyObject *__pyx_n_s_I_LABEL_INVARIANT_PROPERTIES; +static PyObject *__pyx_n_s_I_LABEL_SORTED; +static PyObject *__pyx_kp_s_Incompatible_or_invalid_arc_type; +static PyObject *__pyx_kp_s_Incompatible_or_invalid_weight; +static PyObject *__pyx_kp_s_Incompatible_or_invalid_weight_t; +static PyObject *__pyx_n_s_IndexError; +static PyObject *__pyx_kp_s_Invalid_weight; +static PyObject *__pyx_n_s_KeyError; +static PyObject *__pyx_kp_s_Key_out_of_order; +static PyObject *__pyx_n_s_MUTABLE; +static PyObject *__pyx_kp_s_MutableArcIterator_at_0x_x; +static PyObject *__pyx_n_s_NEG_TRINARY_PROPERTIES; +static PyObject *__pyx_n_s_NON_I_DETERMINISTIC; +static PyObject *__pyx_n_s_NON_O_DETERMINISTIC; +static PyObject *__pyx_n_s_NOT_ACCEPTOR; +static PyObject *__pyx_n_s_NOT_ACCESSIBLE; +static PyObject *__pyx_n_s_NOT_COACCESSIBLE; +static PyObject *__pyx_n_s_NOT_I_LABEL_SORTED; +static PyObject *__pyx_n_s_NOT_O_LABEL_SORTED; +static PyObject *__pyx_n_s_NOT_STRING; +static PyObject *__pyx_n_s_NOT_TOP_SORTED; +static PyObject *__pyx_n_s_NO_EPSILONS; +static PyObject *__pyx_n_s_NO_I_EPSILONS; +static PyObject *__pyx_n_s_NO_LABEL; +static PyObject *__pyx_n_s_NO_O_EPSILONS; +static PyObject *__pyx_n_s_NO_STATE_ID; +static PyObject *__pyx_n_s_NO_SYMBOL; +static PyObject *__pyx_n_s_NULL_PROPERTIES; +static PyObject *__pyx_n_s_NoWeight; +static PyObject *__pyx_kp_s_No_new_SymbolTables_specified; +static PyObject *__pyx_kp_s_No_relabeling_pairs_specified; +static PyObject *__pyx_n_s_Number; +static PyObject *__pyx_n_s_O_DETERMINISTIC; +static PyObject *__pyx_n_s_O_EPSILONS; +static PyObject *__pyx_n_s_O_LABEL_INVARIANT_PROPERTIES; +static PyObject *__pyx_n_s_O_LABEL_SORTED; +static PyObject *__pyx_n_s_One; +static PyObject *__pyx_kp_s_Open_failed_r; +static PyObject *__pyx_kp_s_Operation_failed; +static PyObject *__pyx_n_s_PIPE; +static PyObject *__pyx_n_s_POS_TRINARY_PROPERTIES; +static PyObject *__pyx_n_s_Popen; +static PyObject *__pyx_n_s_RM_SUPERFINAL_PROPERTIES; +static PyObject *__pyx_kp_s_Read_failed_r; +static PyObject *__pyx_kp_s_Read_failed_string; +static PyObject *__pyx_n_s_RuntimeError; +static PyObject *__pyx_n_s_SET_ARC_PROPERTIES; +static PyObject *__pyx_n_s_SET_FINAL_PROPERTIES; +static PyObject *__pyx_n_s_SET_START_PROPERTIES; +static PyObject *__pyx_n_s_STATE_SORT_PROPERTIES; +static PyObject *__pyx_n_s_STRING; +static PyObject *__pyx_kp_s_StateIterator_at_0x_x; +static PyObject *__pyx_kp_s_State_index_out_of_range; +static PyObject *__pyx_n_s_StopIteration; +static PyObject *__pyx_kp_s_SymbolTableIterator_at_0x_x; +static PyObject *__pyx_kp_s_SymbolTable_r_at_0x_x; +static PyObject *__pyx_n_s_TOP_SORTED; +static PyObject *__pyx_n_s_TRINARY_PROPERTIES; +static PyObject *__pyx_kp_s_Tsvg; +static PyObject *__pyx_n_s_TypeError; +static PyObject *__pyx_n_s_UNWEIGHTED; +static PyObject *__pyx_n_s_UNWEIGHTED_CYCLES; +static PyObject *__pyx_kp_s_Unknown_arc_type_r; +static PyObject *__pyx_kp_s_Unknown_compose_filter_type_r; +static PyObject *__pyx_kp_s_Unknown_determinization_type_r; +static PyObject *__pyx_kp_s_Unknown_map_type_r; +static PyObject *__pyx_kp_s_Unknown_queue_type_r; +static PyObject *__pyx_kp_s_Unknown_random_arc_selection_typ; +static PyObject *__pyx_kp_s_Unknown_replace_label_type_r; +static PyObject *__pyx_kp_s_Unknown_sort_type_r; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_WEIGHTED; +static PyObject *__pyx_n_s_WEIGHTED_CYCLES; +static PyObject *__pyx_n_s_WEIGHT_INVARIANT_PROPERTIES; +static PyObject *__pyx_kp_s_Weight_at_0x_x; +static PyObject *__pyx_kp_s_Weight_type_not_found; +static PyObject *__pyx_kp_s_Write_failed_r; +static PyObject *__pyx_kp_s_Write_to_string_failed; +static PyObject *__pyx_n_s_Zero; +static PyObject *__pyx_kp_b__24; +static PyObject *__pyx_n_s_acceptor; +static PyObject *__pyx_n_s_add; +static PyObject *__pyx_n_s_add_state; +static PyObject *__pyx_n_s_add_symbol; +static PyObject *__pyx_n_s_add_table; +static PyObject *__pyx_n_s_allow_negative_labels; +static PyObject *__pyx_n_s_allow_nondet; +static PyObject *__pyx_n_s_arc; +static PyObject *__pyx_n_s_arc_type; +static PyObject *__pyx_n_s_arcs; +static PyObject *__pyx_n_s_atexit; +static PyObject *__pyx_n_s_attach_new_isymbols; +static PyObject *__pyx_n_s_attach_new_osymbols; +static PyObject *__pyx_n_b_auto; +static PyObject *__pyx_n_s_available_key; +static PyObject *__pyx_n_s_call_arc_labeling; +static PyObject *__pyx_n_s_checksum; +static PyObject *__pyx_n_s_class; +static PyObject *__pyx_n_s_cline_in_traceback; +static PyObject *__pyx_n_s_closure_plus; +static PyObject *__pyx_n_s_cls; +static PyObject *__pyx_n_s_communicate; +static PyObject *__pyx_n_s_compile; +static PyObject *__pyx_n_s_compose_filter; +static PyObject *__pyx_n_s_connect; +static PyObject *__pyx_kp_s_const_EncodeMapper_SymbolTable; +static PyObject *__pyx_kp_s_const_Fst_SymbolTable_r_at_0x_x; +static PyObject *__pyx_n_s_copy; +static PyObject *__pyx_n_s_create; +static PyObject *__pyx_n_s_decode; +static PyObject *__pyx_n_b_default; +static PyObject *__pyx_n_s_delta; +static PyObject *__pyx_n_s_det_type; +static PyObject *__pyx_n_s_distance; +static PyObject *__pyx_n_s_divide; +static PyObject *__pyx_n_s_doc; +static PyObject *__pyx_n_s_done; +static PyObject *__pyx_n_s_dot; +static PyObject *__pyx_n_s_draw; +static PyObject *__pyx_n_s_encode; +static PyObject *__pyx_n_s_encode_labels; +static PyObject *__pyx_n_s_encode_weights; +static PyObject *__pyx_n_s_eps_norm_output; +static PyObject *__pyx_n_s_epsilon_on_replace; +static PyObject *__pyx_n_s_error; +static PyObject *__pyx_n_s_far_type; +static PyObject *__pyx_n_s_filename; +static PyObject *__pyx_n_s_final; +static PyObject *__pyx_n_s_find; +static PyObject *__pyx_n_s_flags; +static PyObject *__pyx_n_s_float_format; +static PyObject *__pyx_n_s_fontsize; +static PyObject *__pyx_n_s_format; +static PyObject *__pyx_n_s_fst_error_fatal_old; +static PyObject *__pyx_n_s_fst_type; +static PyObject *__pyx_n_b_functional; +static PyObject *__pyx_n_b_g; +static PyObject *__pyx_n_s_get_fst; +static PyObject *__pyx_n_s_get_key; +static PyObject *__pyx_n_s_get_nth_key; +static PyObject *__pyx_n_s_getstate; +static PyObject *__pyx_n_s_height; +static PyObject *__pyx_n_s_id; +static PyObject *__pyx_n_b_identity; +static PyObject *__pyx_n_s_ifst; +static PyObject *__pyx_n_s_ifst1; +static PyObject *__pyx_n_s_ifst2; +static PyObject *__pyx_n_b_ilabel; +static PyObject *__pyx_n_s_ilabel; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_increment_subsequential_label; +static PyObject *__pyx_n_b_input; +static PyObject *__pyx_n_s_input_symbols; +static PyObject *__pyx_n_s_input_table; +static PyObject *__pyx_n_s_ipairs; +static PyObject *__pyx_n_s_isymbols; +static PyObject *__pyx_n_s_kNoSymbol; +static PyObject *__pyx_n_s_keep_isymbols; +static PyObject *__pyx_n_s_keep_osymbols; +static PyObject *__pyx_n_s_keep_state_numbering; +static PyObject *__pyx_n_s_key; +static PyObject *__pyx_n_s_labeled_checksum; +static PyObject *__pyx_n_s_lhs; +static PyObject *__pyx_n_s_logging; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_map_type; +static PyObject *__pyx_n_s_mask; +static PyObject *__pyx_n_s_max_length; +static PyObject *__pyx_n_s_member; +static PyObject *__pyx_n_s_metaclass; +static PyObject *__pyx_n_s_missing_sym; +static PyObject *__pyx_n_s_module; +static PyObject *__pyx_n_s_mutable_arcs; +static PyObject *__pyx_n_s_n; +static PyObject *__pyx_n_s_name; +static PyObject *__pyx_n_s_name_2; +static PyObject *__pyx_n_b_neither; +static PyObject *__pyx_n_s_new; +static PyObject *__pyx_n_s_new_isymbols; +static PyObject *__pyx_n_s_new_osymbols; +static PyObject *__pyx_n_s_next; +static PyObject *__pyx_n_s_nextstate; +static PyObject *__pyx_kp_s_no_default___reduce___due_to_non; +static PyObject *__pyx_n_s_nodesep; +static PyObject *__pyx_n_s_npath; +static PyObject *__pyx_n_s_nshortest; +static PyObject *__pyx_n_s_nstate; +static PyObject *__pyx_n_s_num_arcs; +static PyObject *__pyx_n_s_num_input_epsilons; +static PyObject *__pyx_n_s_num_output_epsilons; +static PyObject *__pyx_n_s_num_states; +static PyObject *__pyx_n_s_num_symbols; +static PyObject *__pyx_n_s_numbers; +static PyObject *__pyx_n_s_object; +static PyObject *__pyx_n_s_olabel; +static PyObject *__pyx_n_s_old_isymbols; +static PyObject *__pyx_n_s_old_osymbols; +static PyObject *__pyx_n_s_opairs; +static PyObject *__pyx_n_s_open; +static PyObject *__pyx_n_s_osymbols; +static PyObject *__pyx_n_s_output_symbols; +static PyObject *__pyx_n_s_pairs; +static PyObject *__pyx_n_s_plus; +static PyObject *__pyx_n_s_portrait; +static PyObject *__pyx_n_s_position; +static PyObject *__pyx_n_s_potentials; +static PyObject *__pyx_n_s_power; +static PyObject *__pyx_n_s_precision; +static PyObject *__pyx_n_s_prepare; +static PyObject *__pyx_n_s_project_output; +static PyObject *__pyx_n_s_properties; +static PyObject *__pyx_n_s_props; +static PyObject *__pyx_n_s_push_labels; +static PyObject *__pyx_n_s_push_weights; +static PyObject *__pyx_kp_b_pywrapfst; +static PyObject *__pyx_n_s_pywrapfst_2; +static PyObject *__pyx_kp_s_pywrapfst_pyx; +static PyObject *__pyx_n_s_pyx_vtable; +static PyObject *__pyx_n_s_qualname; +static PyObject *__pyx_n_s_queue_type; +static PyObject *__pyx_n_s_ranksep; +static PyObject *__pyx_n_s_read; +static PyObject *__pyx_n_s_read_from_string; +static PyObject *__pyx_n_s_read_from_string_2; +static PyObject *__pyx_n_s_read_fst; +static PyObject *__pyx_n_s_read_text; +static PyObject *__pyx_n_s_reduce; +static PyObject *__pyx_n_s_reduce_cython; +static PyObject *__pyx_n_s_reduce_ex; +static PyObject *__pyx_n_s_register; +static PyObject *__pyx_n_s_remove_common_affix; +static PyObject *__pyx_n_s_remove_total_weight; +static PyObject *__pyx_n_b_repr_svg; +static PyObject *__pyx_n_s_require_superinitial; +static PyObject *__pyx_n_s_reset; +static PyObject *__pyx_n_s_reset_fst_error_fatal; +static PyObject *__pyx_n_s_result; +static PyObject *__pyx_n_s_return_arc_labeling; +static PyObject *__pyx_n_s_return_label; +static PyObject *__pyx_n_s_returncode; +static PyObject *__pyx_n_s_reverse; +static PyObject *__pyx_n_s_rhs; +static PyObject *__pyx_n_s_seed; +static PyObject *__pyx_n_s_seek; +static PyObject *__pyx_n_s_select; +static PyObject *__pyx_kp_s_self__aiter_self__fst_cannot_be; +static PyObject *__pyx_kp_s_self__aiter_self__mfst_cannot_be; +static PyObject *__pyx_kp_s_self__arc_cannot_be_converted_to; +static PyObject *__pyx_kp_s_self__encoder_cannot_be_converte; +static PyObject *__pyx_kp_s_self__encoder_self__table_cannot; +static PyObject *__pyx_kp_s_self__fst_self__siter_cannot_be; +static PyObject *__pyx_kp_s_self__fst_self__table_cannot_be; +static PyObject *__pyx_kp_s_self__mfst_self__table_cannot_be; +static PyObject *__pyx_kp_s_self__reader_cannot_be_converted; +static PyObject *__pyx_kp_s_self__siter_self__table_cannot_b; +static PyObject *__pyx_kp_s_self__smart_table_self__table_ca; +static PyObject *__pyx_kp_s_self__table_cannot_be_converted; +static PyObject *__pyx_kp_s_self__weight_cannot_be_converted; +static PyObject *__pyx_kp_s_self__writer_cannot_be_converted; +static PyObject *__pyx_n_s_set_flags; +static PyObject *__pyx_n_s_set_input_symbols; +static PyObject *__pyx_n_s_set_name; +static PyObject *__pyx_n_s_set_output_symbols; +static PyObject *__pyx_n_s_set_value; +static PyObject *__pyx_n_s_setstate; +static PyObject *__pyx_n_s_setstate_cython; +static PyObject *__pyx_n_s_shortestdistance; +static PyObject *__pyx_n_s_show_weight_one; +static PyObject *__pyx_n_s_sort_type; +static PyObject *__pyx_n_s_ssymbols; +static PyObject *__pyx_n_b_standard; +static PyObject *__pyx_n_s_start; +static PyObject *__pyx_n_s_state; +static PyObject *__pyx_n_s_states; +static PyObject *__pyx_n_s_staticmethod; +static PyObject *__pyx_n_s_stderr; +static PyObject *__pyx_n_s_stdin; +static PyObject *__pyx_n_s_stdout; +static PyObject *__pyx_n_s_subprocess; +static PyObject *__pyx_n_s_subsequential_label; +static PyObject *__pyx_n_s_symbol; +static PyObject *__pyx_n_s_syms; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_n_s_test_2; +static PyObject *__pyx_n_s_text; +static PyObject *__pyx_n_s_times; +static PyObject *__pyx_n_s_title; +static PyObject *__pyx_n_s_to_final; +static PyObject *__pyx_n_s_to_string; +static PyObject *__pyx_n_b_tropical; +static PyObject *__pyx_n_s_type; +static PyObject *__pyx_n_b_uniform; +static PyObject *__pyx_n_s_unique; +static PyObject *__pyx_n_s_unknown_isymbol; +static PyObject *__pyx_n_s_unknown_osymbol; +static PyObject *__pyx_kp_b_unspecified; +static PyObject *__pyx_n_s_utf8; +static PyObject *__pyx_n_s_value; +static PyObject *__pyx_n_b_vector; +static PyObject *__pyx_n_s_verify; +static PyObject *__pyx_n_s_vertical; +static PyObject *__pyx_n_s_w; +static PyObject *__pyx_n_s_warning; +static PyObject *__pyx_n_s_weight; +static PyObject *__pyx_n_s_weight_type; +static PyObject *__pyx_n_s_weighted; +static PyObject *__pyx_n_s_width; +static PyObject *__pyx_n_s_write; +static PyObject *__pyx_n_s_write_text; +static PyObject *__pyx_n_b_write_to_string; +static PyObject *__pyx_n_s_write_to_string; +static PyObject *__pyx_pf_9pywrapfst_6Weight___repr__(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_6Weight_2__str__(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_6Weight_4__float__(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self); /* proto */ +static int __pyx_pf_9pywrapfst_6Weight_6__init__(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self, PyObject *__pyx_v_weight_type, PyObject *__pyx_v_weight); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_6Weight_8copy(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_6Weight_10Zero(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_weight_type); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_6Weight_12One(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_weight_type); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_6Weight_14NoWeight(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_weight_type); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_6Weight_16__eq__(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_w1, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_w2); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_6Weight_18__ne__(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_w1, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_w2); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_6Weight_20to_string(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_6Weight_22type(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_6Weight_24__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_6Weight_26__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_plus(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_2times(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4divide(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_6power(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_w, size_t __pyx_v_n); /* proto */ +static int __pyx_pf_9pywrapfst_12_SymbolTable___init__(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_2__iter__(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_4available_key(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_6checksum(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_8copy(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_10find(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_12get_nth_key(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, Py_ssize_t __pyx_v_pos); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_14labeled_checksum(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_16member(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ +static int __pyx_pf_9pywrapfst_12_SymbolTable_18__contains__(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_20name(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_22num_symbols(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_24write(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_filename); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_26write_text(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_filename); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_28__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_30__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_24_EncodeMapperSymbolTable___repr__(struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_24_EncodeMapperSymbolTable_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_24_EncodeMapperSymbolTable_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_15_FstSymbolTable___repr__(struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_15_FstSymbolTable_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_15_FstSymbolTable_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_19_MutableSymbolTable_add_symbol(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, PyObject *__pyx_v_symbol, __pyx_t_10basictypes_int64 __pyx_v_key); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_19_MutableSymbolTable_2add_table(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_19_MutableSymbolTable_4set_name(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, PyObject *__pyx_v_new_name); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_19_MutableSymbolTable_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_19_MutableSymbolTable_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_22_MutableFstSymbolTable___repr__(struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_22_MutableFstSymbolTable_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_22_MutableFstSymbolTable_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11SymbolTable___repr__(struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_self); /* proto */ +static int __pyx_pf_9pywrapfst_11SymbolTable_2__init__(struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11SymbolTable_4read(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_filename); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11SymbolTable_6read_text(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_filename, bool __pyx_v_allow_negative_labels); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11SymbolTable_8read_fst(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_filename, bool __pyx_v_input_table); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11SymbolTable_10__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11SymbolTable_12__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_8compact_symbol_table(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_10merge_symbol_table(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_lhs, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_rhs); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator___repr__(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self); /* proto */ +static int __pyx_pf_9pywrapfst_19SymbolTableIterator_2__init__(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_4__iter__(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_6__next__(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_8done(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_10next(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_12reset(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_14symbol(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_16value(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_18__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_20__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper___repr__(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self); /* proto */ +static int __pyx_pf_9pywrapfst_12EncodeMapper_2__init__(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, PyObject *__pyx_v_arc_type, bool __pyx_v_encode_labels, bool __pyx_v_encode_weights); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_4arc_type(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_6__call__(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_8flags(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_10input_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_12output_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_14properties(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_mask); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_16set_input_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_18set_output_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_20weight_type(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_22__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_24__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4_Fst__repr_svg_(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4_Fst_2__repr__(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */ +static int __pyx_pf_9pywrapfst_4_Fst_4__init__(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4_Fst_6__str__(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4_Fst_8__reduce__(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4_Fst_10arc_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4_Fst_12arcs(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4_Fst_14copy(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4_Fst_16draw(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, PyObject *__pyx_v_filename, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_isymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_osymbols, struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_ssymbols, bool __pyx_v_acceptor, PyObject *__pyx_v_title, double __pyx_v_width, double __pyx_v_height, bool __pyx_v_portrait, bool __pyx_v_vertical, double __pyx_v_ranksep, double __pyx_v_nodesep, __pyx_t_10basictypes_int32 __pyx_v_fontsize, __pyx_t_10basictypes_int32 __pyx_v_precision, PyObject *__pyx_v_float_format, bool __pyx_v_show_weight_one); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4_Fst_18final(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4_Fst_20fst_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4_Fst_22input_symbols(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4_Fst_24num_arcs(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4_Fst_26num_input_epsilons(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4_Fst_28num_output_epsilons(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4_Fst_30output_symbols(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4_Fst_32properties(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_mask, bool __pyx_v_test); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4_Fst_34start(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4_Fst_36states(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4_Fst_38text(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_isymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_osymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_ssymbols, bool __pyx_v_acceptor, bool __pyx_v_show_weight_one, PyObject *__pyx_v_missing_sym); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4_Fst_40verify(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4_Fst_42weight_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4_Fst_44write(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, PyObject *__pyx_v_filename); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_4_Fst_46write_to_string(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_add_arc(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_2add_state(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_4arcsort(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, PyObject *__pyx_v_sort_type); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_6closure(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, bool __pyx_v_closure_plus); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_8concat(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_10connect(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_12decode(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_encoder); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_14delete_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, size_t __pyx_v_n); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_16delete_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, PyObject *__pyx_v_states); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_18encode(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_encoder); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_20invert(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_22minimize(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, float __pyx_v_delta, bool __pyx_v_allow_nondet); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_24mutable_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_26mutable_input_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_28mutable_output_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_30num_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_32project(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, bool __pyx_v_project_output); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_34prune(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, float __pyx_v_delta, __pyx_t_10basictypes_int64 __pyx_v_nstate, PyObject *__pyx_v_weight); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_36push(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, float __pyx_v_delta, bool __pyx_v_remove_total_weight, bool __pyx_v_to_final); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_38relabel_pairs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, PyObject *__pyx_v_ipairs, PyObject *__pyx_v_opairs); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_40relabel_tables(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_old_isymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_new_isymbols, PyObject *__pyx_v_unknown_isymbol, bool __pyx_v_attach_new_isymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_old_osymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_new_osymbols, PyObject *__pyx_v_unknown_osymbol, bool __pyx_v_attach_new_osymbols); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_42reserve_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, size_t __pyx_v_n); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_44reserve_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_n); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_46reweight(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, PyObject *__pyx_v_potentials, bool __pyx_v_to_final); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_48rmepsilon(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, PyObject *__pyx_v_queue_type, bool __pyx_v_connect, PyObject *__pyx_v_weight, __pyx_t_10basictypes_int64 __pyx_v_nstate, float __pyx_v_delta); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_50set_final(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, PyObject *__pyx_v_weight); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_52set_input_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_54set_output_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_56set_properties(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_props, __pyx_t_10basictypes_uint64 __pyx_v_mask); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_58set_start(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_60topsort(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_62union(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_12_read(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_filename); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_14_read_from_string(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_3Fst___new__(CYTHON_UNUSED PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_cls, PyObject *__pyx_v_arc_type); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_3Fst_2read(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_filename); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_3Fst_4read_from_string(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_3Arc___repr__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self); /* proto */ +static int __pyx_pf_9pywrapfst_3Arc_2__init__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_ilabel, __pyx_t_10basictypes_int64 __pyx_v_olabel, PyObject *__pyx_v_weight, __pyx_t_10basictypes_int64 __pyx_v_nextstate); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_3Arc_4copy(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_3Arc_6ilabel___get__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self); /* proto */ +static int __pyx_pf_9pywrapfst_3Arc_6ilabel_2__set__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_3Arc_6olabel___get__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self); /* proto */ +static int __pyx_pf_9pywrapfst_3Arc_6olabel_2__set__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_3Arc_6weight___get__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self); /* proto */ +static int __pyx_pf_9pywrapfst_3Arc_6weight_2__set__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, PyObject *__pyx_v_weight); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_3Arc_9nextstate___get__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self); /* proto */ +static int __pyx_pf_9pywrapfst_3Arc_9nextstate_2__set__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_3Arc_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_3Arc_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator___repr__(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self); /* proto */ +static int __pyx_pf_9pywrapfst_11ArcIterator_2__init__(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, __pyx_t_10basictypes_int64 __pyx_v_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_4__iter__(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_6__next__(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_8done(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_10flags(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_12next(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_14position(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_16reset(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_18seek(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, size_t __pyx_v_a); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_20set_flags(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, __pyx_t_10basictypes_uint32 __pyx_v_flags, __pyx_t_10basictypes_uint32 __pyx_v_mask); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_22value(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_24__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_26__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator___repr__(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self); /* proto */ +static int __pyx_pf_9pywrapfst_18MutableArcIterator_2__init__(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_ifst, __pyx_t_10basictypes_int64 __pyx_v_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_4done(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_6flags(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_8next(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_10position(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_12reset(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_14seek(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, size_t __pyx_v_a); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_16set_flags(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, __pyx_t_10basictypes_uint32 __pyx_v_flags, __pyx_t_10basictypes_uint32 __pyx_v_mask); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_18set_value(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_20value(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_22__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_24__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_13StateIterator___repr__(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self); /* proto */ +static int __pyx_pf_9pywrapfst_13StateIterator_2__init__(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_13StateIterator_4__iter__(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_13StateIterator_6__next__(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_13StateIterator_8done(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_13StateIterator_10next(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_13StateIterator_12reset(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_13StateIterator_14value(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_13StateIterator_16__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_13StateIterator_18__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_16arcmap(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, PyObject *__pyx_v_map_type, double __pyx_v_power, PyObject *__pyx_v_weight); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_18compose(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, PyObject *__pyx_v_compose_filter, bool __pyx_v_connect); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_20convert(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, PyObject *__pyx_v_fst_type); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_22determinize(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, PyObject *__pyx_v_det_type, __pyx_t_10basictypes_int64 __pyx_v_nstate, __pyx_t_10basictypes_int64 __pyx_v_subsequential_label, PyObject *__pyx_v_weight, bool __pyx_v_increment_subsequential_label); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_24difference(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, PyObject *__pyx_v_compose_filter, bool __pyx_v_connect); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_26disambiguate(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, __pyx_t_10basictypes_int64 __pyx_v_nstate, __pyx_t_10basictypes_int64 __pyx_v_subsequential_label, PyObject *__pyx_v_weight); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_28epsnormalize(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, bool __pyx_v_eps_norm_output); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_30equal(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, float __pyx_v_delta); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_32equivalent(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, float __pyx_v_delta); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_34intersect(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, PyObject *__pyx_v_compose_filter, bool __pyx_v_connect); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_36isomorphic(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, float __pyx_v_delta); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_38prune(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, __pyx_t_10basictypes_int64 __pyx_v_nstate, PyObject *__pyx_v_weight); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_40push(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, bool __pyx_v_push_weights, bool __pyx_v_push_labels, bool __pyx_v_remove_common_affix, bool __pyx_v_remove_total_weight, bool __pyx_v_to_final); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_42randequivalent(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, __pyx_t_10basictypes_int32 __pyx_v_npath, float __pyx_v_delta, time_t __pyx_v_seed, PyObject *__pyx_v_select, __pyx_t_10basictypes_int32 __pyx_v_max_length); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_44randgen(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, __pyx_t_10basictypes_int32 __pyx_v_npath, time_t __pyx_v_seed, PyObject *__pyx_v_select, __pyx_t_10basictypes_int32 __pyx_v_max_length, bool __pyx_v_weighted, bool __pyx_v_remove_total_weight); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_46replace(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_pairs, PyObject *__pyx_v_call_arc_labeling, PyObject *__pyx_v_return_arc_labeling, bool __pyx_v_epsilon_on_replace, __pyx_t_10basictypes_int64 __pyx_v_return_label); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_48reverse(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, bool __pyx_v_require_superinitial); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_50shortestdistance(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, __pyx_t_10basictypes_int64 __pyx_v_nstate, PyObject *__pyx_v_queue_type, bool __pyx_v_reverse); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_52shortestpath(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, __pyx_t_10basictypes_int32 __pyx_v_nshortest, __pyx_t_10basictypes_int64 __pyx_v_nstate, PyObject *__pyx_v_queue_type, bool __pyx_v_unique, PyObject *__pyx_v_weight); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_54statemap(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, PyObject *__pyx_v_map_type); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_56synchronize(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst); /* proto */ +static int __pyx_pf_9pywrapfst_8Compiler___cinit__(struct __pyx_obj_9pywrapfst_Compiler *__pyx_v_self, std::string __pyx_v_fst_type, std::string __pyx_v_arc_type, struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_isymbols, struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_osymbols, struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_ssymbols, bool __pyx_v_acceptor, bool __pyx_v_keep_isymbols, bool __pyx_v_keep_osymbols, bool __pyx_v_keep_state_numbering, bool __pyx_v_allow_negative_labels); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_8Compiler_2compile(struct __pyx_obj_9pywrapfst_Compiler *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_8Compiler_4write(struct __pyx_obj_9pywrapfst_Compiler *__pyx_v_self, PyObject *__pyx_v_expression); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_8Compiler_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_Compiler *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_8Compiler_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_Compiler *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_9pywrapfst_9FarReader___init__(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_9FarReader_2__repr__(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_9FarReader_4open(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_filenames); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_9FarReader_6arc_type(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_9FarReader_8done(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_9FarReader_10error(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_9FarReader_12far_type(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_9FarReader_14find(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_9FarReader_16get_fst(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_9FarReader_18get_key(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_9FarReader_20next(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_9FarReader_22reset(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_9FarReader_24__getitem__(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_9FarReader_26__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_9FarReader_28__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_9pywrapfst_9FarWriter___init__(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_9FarWriter_2__repr__(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_9FarWriter_4create(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_filename, PyObject *__pyx_v_arc_type, PyObject *__pyx_v_far_type); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_9FarWriter_6add(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, PyObject *__pyx_v_key, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_9FarWriter_8arc_type(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_9FarWriter_10error(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_9FarWriter_12far_type(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self); /* proto */ +static int __pyx_pf_9pywrapfst_9FarWriter_14__setitem__(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, PyObject *__pyx_v_key, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_fst); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_9FarWriter_16__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_9FarWriter_18__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pywrapfst_58_reset_fst_error_fatal(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_tp_new_9pywrapfst_Weight(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pywrapfst__SymbolTable(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pywrapfst__EncodeMapperSymbolTable(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pywrapfst__FstSymbolTable(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pywrapfst__MutableSymbolTable(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pywrapfst__MutableFstSymbolTable(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pywrapfst_SymbolTable(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pywrapfst_SymbolTableIterator(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pywrapfst_EncodeMapper(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pywrapfst__Fst(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pywrapfst__MutableFst(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pywrapfst_Arc(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pywrapfst_ArcIterator(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pywrapfst_MutableArcIterator(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pywrapfst_StateIterator(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pywrapfst_Compiler(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pywrapfst_FarReader(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pywrapfst_FarWriter(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_int_0; +static PyObject *__pyx_int_neg_1; +static __pyx_t_10basictypes_int64 __pyx_k__13; +static float __pyx_k__35; +static float __pyx_k__36; +static float __pyx_k__37; +static __pyx_t_10basictypes_int64 __pyx_k__38; +static float __pyx_k__39; +static __pyx_t_10basictypes_int64 __pyx_k__40; +static float __pyx_k__41; +static float __pyx_k__42; +static __pyx_t_10basictypes_int64 __pyx_k__46; +static float __pyx_k__47; +static __pyx_t_10basictypes_int64 __pyx_k__48; +static float __pyx_k__49; +static float __pyx_k__67; +static float __pyx_k__68; +static float __pyx_k__69; +static __pyx_t_10basictypes_int64 __pyx_k__70; +static float __pyx_k__71; +static __pyx_t_10basictypes_int64 __pyx_k__72; +static float __pyx_k__73; +static float __pyx_k__74; +static float __pyx_k__75; +static float __pyx_k__76; +static __pyx_t_10basictypes_int64 __pyx_k__77; +static float __pyx_k__78; +static float __pyx_k__79; +static __pyx_t_10basictypes_int32 __pyx_k__80; +static __pyx_t_10basictypes_int32 __pyx_k__81; +static float __pyx_k__82; +static __pyx_t_10basictypes_int64 __pyx_k__83; +static float __pyx_k__84; +static __pyx_t_10basictypes_int64 __pyx_k__85; +static float __pyx_k__86; +static __pyx_t_10basictypes_int64 __pyx_k__87; +static std::string __pyx_k__88; +static std::string __pyx_k__89; +static PyObject *__pyx_tuple_; +static PyObject *__pyx_tuple__2; +static PyObject *__pyx_tuple__3; +static PyObject *__pyx_tuple__4; +static PyObject *__pyx_tuple__5; +static PyObject *__pyx_tuple__6; +static PyObject *__pyx_tuple__7; +static PyObject *__pyx_tuple__8; +static PyObject *__pyx_tuple__9; +static PyObject *__pyx_tuple__10; +static PyObject *__pyx_tuple__11; +static PyObject *__pyx_tuple__12; +static PyObject *__pyx_tuple__14; +static PyObject *__pyx_tuple__15; +static PyObject *__pyx_tuple__16; +static PyObject *__pyx_tuple__17; +static PyObject *__pyx_tuple__18; +static PyObject *__pyx_tuple__19; +static PyObject *__pyx_tuple__20; +static PyObject *__pyx_tuple__21; +static PyObject *__pyx_tuple__22; +static PyObject *__pyx_tuple__23; +static PyObject *__pyx_tuple__25; +static PyObject *__pyx_tuple__26; +static PyObject *__pyx_tuple__27; +static PyObject *__pyx_tuple__28; +static PyObject *__pyx_tuple__29; +static PyObject *__pyx_tuple__30; +static PyObject *__pyx_tuple__31; +static PyObject *__pyx_tuple__32; +static PyObject *__pyx_tuple__33; +static PyObject *__pyx_tuple__34; +static PyObject *__pyx_tuple__43; +static PyObject *__pyx_tuple__44; +static PyObject *__pyx_tuple__45; +static PyObject *__pyx_tuple__50; +static PyObject *__pyx_tuple__51; +static PyObject *__pyx_tuple__52; +static PyObject *__pyx_tuple__53; +static PyObject *__pyx_tuple__54; +static PyObject *__pyx_tuple__55; +static PyObject *__pyx_tuple__56; +static PyObject *__pyx_tuple__57; +static PyObject *__pyx_tuple__58; +static PyObject *__pyx_tuple__59; +static PyObject *__pyx_tuple__60; +static PyObject *__pyx_tuple__61; +static PyObject *__pyx_tuple__62; +static PyObject *__pyx_tuple__63; +static PyObject *__pyx_tuple__64; +static PyObject *__pyx_tuple__65; +static PyObject *__pyx_tuple__66; +static PyObject *__pyx_tuple__90; +static PyObject *__pyx_tuple__91; +static PyObject *__pyx_tuple__92; +static PyObject *__pyx_tuple__93; +static PyObject *__pyx_tuple__94; +static PyObject *__pyx_tuple__95; +static PyObject *__pyx_tuple__96; +static PyObject *__pyx_tuple__97; +static PyObject *__pyx_tuple__98; +static PyObject *__pyx_tuple__99; +static PyObject *__pyx_tuple__101; +static PyObject *__pyx_tuple__103; +static PyObject *__pyx_tuple__105; +static PyObject *__pyx_tuple__107; +static PyObject *__pyx_tuple__108; +static PyObject *__pyx_tuple__110; +static PyObject *__pyx_tuple__111; +static PyObject *__pyx_tuple__113; +static PyObject *__pyx_tuple__115; +static PyObject *__pyx_codeobj__100; +static PyObject *__pyx_codeobj__102; +static PyObject *__pyx_codeobj__104; +static PyObject *__pyx_codeobj__106; +static PyObject *__pyx_codeobj__109; +static PyObject *__pyx_codeobj__112; +static PyObject *__pyx_codeobj__114; +static PyObject *__pyx_codeobj__116; +static PyObject *__pyx_codeobj__117; + +/* "pywrapfst.pyx":159 + * + * + * cdef string tostring(data, encoding="utf8") except *: # <<<<<<<<<<<<<< + * """Converts strings to bytestrings. + * + */ + +static std::string __pyx_f_9pywrapfst_tostring(PyObject *__pyx_v_data, struct __pyx_opt_args_9pywrapfst_tostring *__pyx_optional_args) { + PyObject *__pyx_v_encoding = ((PyObject *)__pyx_n_s_utf8); + std::string __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + std::string __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + __Pyx_RefNannySetupContext("tostring", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_encoding = __pyx_optional_args->encoding; + } + } + + /* "pywrapfst.pyx":180 + * """ + * # A Python bytestring can be implicitly cast to a C++ string. + * if isinstance(data, bytes): # <<<<<<<<<<<<<< + * return data + * elif isinstance(data, unicode): + */ + __pyx_t_1 = PyBytes_Check(__pyx_v_data); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "pywrapfst.pyx":181 + * # A Python bytestring can be implicitly cast to a C++ string. + * if isinstance(data, bytes): + * return data # <<<<<<<<<<<<<< + * elif isinstance(data, unicode): + * return data.encode(encoding) + */ + __pyx_t_3 = __pyx_convert_string_from_py_std__in_string(__pyx_v_data); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 181, __pyx_L1_error) + __pyx_r = __pyx_t_3; + goto __pyx_L0; + + /* "pywrapfst.pyx":180 + * """ + * # A Python bytestring can be implicitly cast to a C++ string. + * if isinstance(data, bytes): # <<<<<<<<<<<<<< + * return data + * elif isinstance(data, unicode): + */ + } + + /* "pywrapfst.pyx":182 + * if isinstance(data, bytes): + * return data + * elif isinstance(data, unicode): # <<<<<<<<<<<<<< + * return data.encode(encoding) + * raise FstArgError("Cannot encode as string: {!r}".format(data)) + */ + __pyx_t_2 = PyUnicode_Check(__pyx_v_data); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":183 + * return data + * elif isinstance(data, unicode): + * return data.encode(encoding) # <<<<<<<<<<<<<< + * raise FstArgError("Cannot encode as string: {!r}".format(data)) + * + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 183, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_6) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_encoding); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 183, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_encoding}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 183, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_encoding}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 183, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 183, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_INCREF(__pyx_v_encoding); + __Pyx_GIVEREF(__pyx_v_encoding); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_encoding); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 183, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_3 = __pyx_convert_string_from_py_std__in_string(__pyx_t_4); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 183, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_3; + goto __pyx_L0; + + /* "pywrapfst.pyx":182 + * if isinstance(data, bytes): + * return data + * elif isinstance(data, unicode): # <<<<<<<<<<<<<< + * return data.encode(encoding) + * raise FstArgError("Cannot encode as string: {!r}".format(data)) + */ + } + + /* "pywrapfst.pyx":184 + * elif isinstance(data, unicode): + * return data.encode(encoding) + * raise FstArgError("Cannot encode as string: {!r}".format(data)) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Cannot_encode_as_string_r, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + if (!__pyx_t_8) { + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_data); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_data}; + __pyx_t_7 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_7); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_data}; + __pyx_t_7 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_7); + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL; + __Pyx_INCREF(__pyx_v_data); + __Pyx_GIVEREF(__pyx_v_data); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_v_data); + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_6) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_7}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_7}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 184, __pyx_L1_error) + + /* "pywrapfst.pyx":159 + * + * + * cdef string tostring(data, encoding="utf8") except *: # <<<<<<<<<<<<<< + * """Converts strings to bytestrings. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("pywrapfst.tostring", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":187 + * + * + * cdef string weight_tostring(data, encoding="utf8") except *: # <<<<<<<<<<<<<< + * """Converts strings or numerics to bytestrings. + * + */ + +static std::string __pyx_f_9pywrapfst_weight_tostring(PyObject *__pyx_v_data, struct __pyx_opt_args_9pywrapfst_weight_tostring *__pyx_optional_args) { + PyObject *__pyx_v_encoding = ((PyObject *)__pyx_n_s_utf8); + std::string __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + std::string __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + __Pyx_RefNannySetupContext("weight_tostring", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_encoding = __pyx_optional_args->encoding; + } + } + + /* "pywrapfst.pyx":211 + * """ + * # A Python bytestring can be implicitly cast to a C++ string. + * if isinstance(data, bytes): # <<<<<<<<<<<<<< + * return data + * elif isinstance(data, unicode): + */ + __pyx_t_1 = PyBytes_Check(__pyx_v_data); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "pywrapfst.pyx":212 + * # A Python bytestring can be implicitly cast to a C++ string. + * if isinstance(data, bytes): + * return data # <<<<<<<<<<<<<< + * elif isinstance(data, unicode): + * return data.encode(encoding) + */ + __pyx_t_3 = __pyx_convert_string_from_py_std__in_string(__pyx_v_data); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 212, __pyx_L1_error) + __pyx_r = __pyx_t_3; + goto __pyx_L0; + + /* "pywrapfst.pyx":211 + * """ + * # A Python bytestring can be implicitly cast to a C++ string. + * if isinstance(data, bytes): # <<<<<<<<<<<<<< + * return data + * elif isinstance(data, unicode): + */ + } + + /* "pywrapfst.pyx":213 + * if isinstance(data, bytes): + * return data + * elif isinstance(data, unicode): # <<<<<<<<<<<<<< + * return data.encode(encoding) + * elif isinstance(data, numbers.Number): + */ + __pyx_t_2 = PyUnicode_Check(__pyx_v_data); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":214 + * return data + * elif isinstance(data, unicode): + * return data.encode(encoding) # <<<<<<<<<<<<<< + * elif isinstance(data, numbers.Number): + * return str(data).encode(encoding) + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_6) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_encoding); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_encoding}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 214, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_encoding}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 214, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_INCREF(__pyx_v_encoding); + __Pyx_GIVEREF(__pyx_v_encoding); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_encoding); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_3 = __pyx_convert_string_from_py_std__in_string(__pyx_t_4); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 214, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_3; + goto __pyx_L0; + + /* "pywrapfst.pyx":213 + * if isinstance(data, bytes): + * return data + * elif isinstance(data, unicode): # <<<<<<<<<<<<<< + * return data.encode(encoding) + * elif isinstance(data, numbers.Number): + */ + } + + /* "pywrapfst.pyx":215 + * elif isinstance(data, unicode): + * return data.encode(encoding) + * elif isinstance(data, numbers.Number): # <<<<<<<<<<<<<< + * return str(data).encode(encoding) + * raise FstArgError("Cannot encode as string: {!r}".format(data)) + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_numbers); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Number); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_1 = PyObject_IsInstance(__pyx_v_data, __pyx_t_5); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "pywrapfst.pyx":216 + * return data.encode(encoding) + * elif isinstance(data, numbers.Number): + * return str(data).encode(encoding) # <<<<<<<<<<<<<< + * raise FstArgError("Cannot encode as string: {!r}".format(data)) + * + */ + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_data); + __Pyx_GIVEREF(__pyx_v_data); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_data); + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_4, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_encode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_7) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_encoding); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_encoding}; + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_encoding}; + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_INCREF(__pyx_v_encoding); + __Pyx_GIVEREF(__pyx_v_encoding); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_encoding); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_3 = __pyx_convert_string_from_py_std__in_string(__pyx_t_5); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_r = __pyx_t_3; + goto __pyx_L0; + + /* "pywrapfst.pyx":215 + * elif isinstance(data, unicode): + * return data.encode(encoding) + * elif isinstance(data, numbers.Number): # <<<<<<<<<<<<<< + * return str(data).encode(encoding) + * raise FstArgError("Cannot encode as string: {!r}".format(data)) + */ + } + + /* "pywrapfst.pyx":217 + * elif isinstance(data, numbers.Number): + * return str(data).encode(encoding) + * raise FstArgError("Cannot encode as string: {!r}".format(data)) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Cannot_encode_as_string_r, __pyx_n_s_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + if (!__pyx_t_8) { + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_data); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_data}; + __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_6); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_data}; + __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_6); + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL; + __Pyx_INCREF(__pyx_v_data); + __Pyx_GIVEREF(__pyx_v_data); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_v_data); + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_7) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 217, __pyx_L1_error) + + /* "pywrapfst.pyx":187 + * + * + * cdef string weight_tostring(data, encoding="utf8") except *: # <<<<<<<<<<<<<< + * """Converts strings or numerics to bytestrings. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("pywrapfst.weight_tostring", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":220 + * + * + * cdef fst.ComposeFilter _get_compose_filter( # <<<<<<<<<<<<<< + * const string &compose_filter) except *: + * """Matches string with the appropriate ComposeFilter enum value. + */ + +static enum fst::ComposeFilter __pyx_f_9pywrapfst__get_compose_filter(std::string const &__pyx_v_compose_filter) { + enum fst::ComposeFilter __pyx_v_compose_filter_enum; + enum fst::ComposeFilter __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("_get_compose_filter", 0); + + /* "pywrapfst.pyx":241 + * """ + * cdef fst.ComposeFilter compose_filter_enum + * if not fst.GetComposeFilter(compose_filter, addr(compose_filter_enum)): # <<<<<<<<<<<<<< + * raise FstArgError("Unknown compose filter type: {!r}".format( + * compose_filter)) + */ + __pyx_t_1 = ((!(fst::script::GetComposeFilter(__pyx_v_compose_filter, (&__pyx_v_compose_filter_enum)) != 0)) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":242 + * cdef fst.ComposeFilter compose_filter_enum + * if not fst.GetComposeFilter(compose_filter, addr(compose_filter_enum)): + * raise FstArgError("Unknown compose filter type: {!r}".format( # <<<<<<<<<<<<<< + * compose_filter)) + * return compose_filter_enum + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Unknown_compose_filter_type_r, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + + /* "pywrapfst.pyx":243 + * if not fst.GetComposeFilter(compose_filter, addr(compose_filter_enum)): + * raise FstArgError("Unknown compose filter type: {!r}".format( + * compose_filter)) # <<<<<<<<<<<<<< + * return compose_filter_enum + * + */ + __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_compose_filter); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_7) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 242, __pyx_L1_error) + + /* "pywrapfst.pyx":241 + * """ + * cdef fst.ComposeFilter compose_filter_enum + * if not fst.GetComposeFilter(compose_filter, addr(compose_filter_enum)): # <<<<<<<<<<<<<< + * raise FstArgError("Unknown compose filter type: {!r}".format( + * compose_filter)) + */ + } + + /* "pywrapfst.pyx":244 + * raise FstArgError("Unknown compose filter type: {!r}".format( + * compose_filter)) + * return compose_filter_enum # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_compose_filter_enum; + goto __pyx_L0; + + /* "pywrapfst.pyx":220 + * + * + * cdef fst.ComposeFilter _get_compose_filter( # <<<<<<<<<<<<<< + * const string &compose_filter) except *: + * """Matches string with the appropriate ComposeFilter enum value. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pywrapfst._get_compose_filter", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = (enum fst::ComposeFilter) 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":247 + * + * + * cdef fst.DeterminizeType _get_determinize_type(const string &det_type) except *: # <<<<<<<<<<<<<< + * """Matches string with the appropriate DeterminizeType enum value. + * + */ + +static enum fst::DeterminizeType __pyx_f_9pywrapfst__get_determinize_type(std::string const &__pyx_v_det_type) { + enum fst::DeterminizeType __pyx_v_det_type_enum; + enum fst::DeterminizeType __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("_get_determinize_type", 0); + + /* "pywrapfst.pyx":263 + * """ + * cdef fst.DeterminizeType det_type_enum + * if not fst.GetDeterminizeType(det_type, addr(det_type_enum)): # <<<<<<<<<<<<<< + * raise FstArgError("Unknown determinization type: {!r}".format(det_type)) + * return det_type_enum + */ + __pyx_t_1 = ((!(fst::script::GetDeterminizeType(__pyx_v_det_type, (&__pyx_v_det_type_enum)) != 0)) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":264 + * cdef fst.DeterminizeType det_type_enum + * if not fst.GetDeterminizeType(det_type, addr(det_type_enum)): + * raise FstArgError("Unknown determinization type: {!r}".format(det_type)) # <<<<<<<<<<<<<< + * return det_type_enum + * + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Unknown_determinization_type_r, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_det_type); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_7) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 264, __pyx_L1_error) + + /* "pywrapfst.pyx":263 + * """ + * cdef fst.DeterminizeType det_type_enum + * if not fst.GetDeterminizeType(det_type, addr(det_type_enum)): # <<<<<<<<<<<<<< + * raise FstArgError("Unknown determinization type: {!r}".format(det_type)) + * return det_type_enum + */ + } + + /* "pywrapfst.pyx":265 + * if not fst.GetDeterminizeType(det_type, addr(det_type_enum)): + * raise FstArgError("Unknown determinization type: {!r}".format(det_type)) + * return det_type_enum # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_det_type_enum; + goto __pyx_L0; + + /* "pywrapfst.pyx":247 + * + * + * cdef fst.DeterminizeType _get_determinize_type(const string &det_type) except *: # <<<<<<<<<<<<<< + * """Matches string with the appropriate DeterminizeType enum value. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pywrapfst._get_determinize_type", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = (enum fst::DeterminizeType) 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":268 + * + * + * cdef fst.QueueType _get_queue_type(const string &queue_type) except *: # <<<<<<<<<<<<<< + * """Matches string with the appropriate QueueType enum value. + * + */ + +static enum fst::QueueType __pyx_f_9pywrapfst__get_queue_type(std::string const &__pyx_v_queue_type) { + enum fst::QueueType __pyx_v_queue_type_enum; + enum fst::QueueType __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("_get_queue_type", 0); + + /* "pywrapfst.pyx":287 + * """ + * cdef fst.QueueType queue_type_enum + * if not fst.GetQueueType(queue_type, addr(queue_type_enum)): # <<<<<<<<<<<<<< + * raise FstArgError("Unknown queue type: {!r}".format(queue_type)) + * return queue_type_enum + */ + __pyx_t_1 = ((!(fst::script::GetQueueType(__pyx_v_queue_type, (&__pyx_v_queue_type_enum)) != 0)) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":288 + * cdef fst.QueueType queue_type_enum + * if not fst.GetQueueType(queue_type, addr(queue_type_enum)): + * raise FstArgError("Unknown queue type: {!r}".format(queue_type)) # <<<<<<<<<<<<<< + * return queue_type_enum + * + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Unknown_queue_type_r, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_queue_type); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_7) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 288, __pyx_L1_error) + + /* "pywrapfst.pyx":287 + * """ + * cdef fst.QueueType queue_type_enum + * if not fst.GetQueueType(queue_type, addr(queue_type_enum)): # <<<<<<<<<<<<<< + * raise FstArgError("Unknown queue type: {!r}".format(queue_type)) + * return queue_type_enum + */ + } + + /* "pywrapfst.pyx":289 + * if not fst.GetQueueType(queue_type, addr(queue_type_enum)): + * raise FstArgError("Unknown queue type: {!r}".format(queue_type)) + * return queue_type_enum # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_queue_type_enum; + goto __pyx_L0; + + /* "pywrapfst.pyx":268 + * + * + * cdef fst.QueueType _get_queue_type(const string &queue_type) except *: # <<<<<<<<<<<<<< + * """Matches string with the appropriate QueueType enum value. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pywrapfst._get_queue_type", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = (enum fst::QueueType) 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":292 + * + * + * cdef fst.RandArcSelection _get_rand_arc_selection( # <<<<<<<<<<<<<< + * const string &select) except *: + * """Matches string with the appropriate RandArcSelection enum value. + */ + +static enum fst::script::RandArcSelection __pyx_f_9pywrapfst__get_rand_arc_selection(std::string const &__pyx_v_select) { + enum fst::script::RandArcSelection __pyx_v_select_enum; + enum fst::script::RandArcSelection __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("_get_rand_arc_selection", 0); + + /* "pywrapfst.pyx":312 + * """ + * cdef fst.RandArcSelection select_enum + * if not fst.GetRandArcSelection(select, addr(select_enum)): # <<<<<<<<<<<<<< + * raise FstArgError("Unknown random arc selection type: {!r}".format(select)) + * return select_enum + */ + __pyx_t_1 = ((!(fst::script::GetRandArcSelection(__pyx_v_select, (&__pyx_v_select_enum)) != 0)) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":313 + * cdef fst.RandArcSelection select_enum + * if not fst.GetRandArcSelection(select, addr(select_enum)): + * raise FstArgError("Unknown random arc selection type: {!r}".format(select)) # <<<<<<<<<<<<<< + * return select_enum + * + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 313, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Unknown_random_arc_selection_typ, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 313, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_select); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 313, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_7) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 313, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 313, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 313, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 313, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 313, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 313, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 313, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 313, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 313, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 313, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 313, __pyx_L1_error) + + /* "pywrapfst.pyx":312 + * """ + * cdef fst.RandArcSelection select_enum + * if not fst.GetRandArcSelection(select, addr(select_enum)): # <<<<<<<<<<<<<< + * raise FstArgError("Unknown random arc selection type: {!r}".format(select)) + * return select_enum + */ + } + + /* "pywrapfst.pyx":314 + * if not fst.GetRandArcSelection(select, addr(select_enum)): + * raise FstArgError("Unknown random arc selection type: {!r}".format(select)) + * return select_enum # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_select_enum; + goto __pyx_L0; + + /* "pywrapfst.pyx":292 + * + * + * cdef fst.RandArcSelection _get_rand_arc_selection( # <<<<<<<<<<<<<< + * const string &select) except *: + * """Matches string with the appropriate RandArcSelection enum value. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pywrapfst._get_rand_arc_selection", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = (enum fst::script::RandArcSelection) 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":317 + * + * + * cdef fst.ReplaceLabelType _get_replace_label_type( # <<<<<<<<<<<<<< + * const string &replace_label_type, bool epsilon_on_replace) except *: + * """Matches string with the appropriate ReplaceLabelType enum value. + */ + +static enum fst::ReplaceLabelType __pyx_f_9pywrapfst__get_replace_label_type(std::string const &__pyx_v_replace_label_type, bool __pyx_v_epsilon_on_replace) { + enum fst::ReplaceLabelType __pyx_v_replace_label_type_enum; + enum fst::ReplaceLabelType __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("_get_replace_label_type", 0); + + /* "pywrapfst.pyx":338 + * """ + * cdef fst.ReplaceLabelType replace_label_type_enum + * if not fst.GetReplaceLabelType(replace_label_type, epsilon_on_replace, # <<<<<<<<<<<<<< + * addr(replace_label_type_enum)): + * raise FstArgError("Unknown replace label type: {!r}".format( + */ + __pyx_t_1 = ((!(fst::script::GetReplaceLabelType(__pyx_v_replace_label_type, __pyx_v_epsilon_on_replace, (&__pyx_v_replace_label_type_enum)) != 0)) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":340 + * if not fst.GetReplaceLabelType(replace_label_type, epsilon_on_replace, + * addr(replace_label_type_enum)): + * raise FstArgError("Unknown replace label type: {!r}".format( # <<<<<<<<<<<<<< + * replace_label_type)) + * return replace_label_type_enum + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 340, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Unknown_replace_label_type_r, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 340, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + + /* "pywrapfst.pyx":341 + * addr(replace_label_type_enum)): + * raise FstArgError("Unknown replace label type: {!r}".format( + * replace_label_type)) # <<<<<<<<<<<<<< + * return replace_label_type_enum + * + */ + __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_replace_label_type); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 341, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_7) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 340, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 340, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 340, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 340, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 340, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 340, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 340, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 340, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 340, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 340, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 340, __pyx_L1_error) + + /* "pywrapfst.pyx":338 + * """ + * cdef fst.ReplaceLabelType replace_label_type_enum + * if not fst.GetReplaceLabelType(replace_label_type, epsilon_on_replace, # <<<<<<<<<<<<<< + * addr(replace_label_type_enum)): + * raise FstArgError("Unknown replace label type: {!r}".format( + */ + } + + /* "pywrapfst.pyx":342 + * raise FstArgError("Unknown replace label type: {!r}".format( + * replace_label_type)) + * return replace_label_type_enum # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_replace_label_type_enum; + goto __pyx_L0; + + /* "pywrapfst.pyx":317 + * + * + * cdef fst.ReplaceLabelType _get_replace_label_type( # <<<<<<<<<<<<<< + * const string &replace_label_type, bool epsilon_on_replace) except *: + * """Matches string with the appropriate ReplaceLabelType enum value. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pywrapfst._get_replace_label_type", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = (enum fst::ReplaceLabelType) 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":368 + * """ + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "<{} Weight {} at 0x{:x}>".format(self.type(), self.to_string(), + * id(self)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_6Weight_1__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_6Weight_1__repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_6Weight___repr__(((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_6Weight___repr__(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "pywrapfst.pyx":369 + * + * def __repr__(self): + * return "<{} Weight {} at 0x{:x}>".format(self.type(), self.to_string(), # <<<<<<<<<<<<<< + * id(self)) + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Weight_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 369, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "type"); + __PYX_ERR(0, 369, __pyx_L1_error) + } + __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_self->__pyx_vtab)->type(__pyx_v_self, 0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 369, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "to_string"); + __PYX_ERR(0, 369, __pyx_L1_error) + } + __pyx_t_4 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_self->__pyx_vtab)->to_string(__pyx_v_self, 0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 369, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "pywrapfst.pyx":370 + * def __repr__(self): + * return "<{} Weight {} at 0x{:x}>".format(self.type(), self.to_string(), + * id(self)) # <<<<<<<<<<<<<< + * + * def __str__(self): + */ + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)__pyx_v_self)); + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_5, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_t_3, __pyx_t_4, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 369, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_t_3, __pyx_t_4, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 369, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 369, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_7, __pyx_t_6); + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_6 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 369, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":368 + * """ + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "<{} Weight {} at 0x{:x}>".format(self.type(), self.to_string(), + * id(self)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pywrapfst.Weight.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":372 + * id(self)) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return self.to_string() + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_6Weight_3__str__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_6Weight_3__str__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_6Weight_2__str__(((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_6Weight_2__str__(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__str__", 0); + + /* "pywrapfst.pyx":373 + * + * def __str__(self): + * return self.to_string() # <<<<<<<<<<<<<< + * + * # This attempts to convert the string form into a float, raising + */ + __Pyx_XDECREF(__pyx_r); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "to_string"); + __PYX_ERR(0, 373, __pyx_L1_error) + } + __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_self->__pyx_vtab)->to_string(__pyx_v_self, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":372 + * id(self)) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return self.to_string() + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Weight.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":378 + * # ValueError when that is not appropriate. + * + * def __float__(self): # <<<<<<<<<<<<<< + * return float(self.to_string()) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_6Weight_5__float__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_6Weight_5__float__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__float__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_6Weight_4__float__(((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_6Weight_4__float__(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__float__", 0); + + /* "pywrapfst.pyx":379 + * + * def __float__(self): + * return float(self.to_string()) # <<<<<<<<<<<<<< + * + * def __init__(self, weight_type, weight): + */ + __Pyx_XDECREF(__pyx_r); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "to_string"); + __PYX_ERR(0, 379, __pyx_L1_error) + } + __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_self->__pyx_vtab)->to_string(__pyx_v_self, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyNumber_Float(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":378 + * # ValueError when that is not appropriate. + * + * def __float__(self): # <<<<<<<<<<<<<< + * return float(self.to_string()) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pywrapfst.Weight.__float__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":381 + * return float(self.to_string()) + * + * def __init__(self, weight_type, weight): # <<<<<<<<<<<<<< + * self._weight.reset(new fst.WeightClass(tostring(weight_type), + * weight_tostring(weight))) + */ + +/* Python wrapper */ +static int __pyx_pw_9pywrapfst_6Weight_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_9pywrapfst_6Weight_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_weight_type = 0; + PyObject *__pyx_v_weight = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_weight_type,&__pyx_n_s_weight,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weight_type)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weight)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); __PYX_ERR(0, 381, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 381, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_weight_type = values[0]; + __pyx_v_weight = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 381, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.Weight.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_6Weight_6__init__(((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_self), __pyx_v_weight_type, __pyx_v_weight); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pywrapfst_6Weight_6__init__(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self, PyObject *__pyx_v_weight_type, PyObject *__pyx_v_weight) { + int __pyx_r; + __Pyx_RefNannyDeclarations + std::string __pyx_t_1; + std::string __pyx_t_2; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "pywrapfst.pyx":382 + * + * def __init__(self, weight_type, weight): + * self._weight.reset(new fst.WeightClass(tostring(weight_type), # <<<<<<<<<<<<<< + * weight_tostring(weight))) + * self._check_weight() + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 382, __pyx_L1_error) + } + __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_weight_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 382, __pyx_L1_error) + + /* "pywrapfst.pyx":383 + * def __init__(self, weight_type, weight): + * self._weight.reset(new fst.WeightClass(tostring(weight_type), + * weight_tostring(weight))) # <<<<<<<<<<<<<< + * self._check_weight() + * + */ + __pyx_t_2 = __pyx_f_9pywrapfst_weight_tostring(__pyx_v_weight, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 383, __pyx_L1_error) + + /* "pywrapfst.pyx":382 + * + * def __init__(self, weight_type, weight): + * self._weight.reset(new fst.WeightClass(tostring(weight_type), # <<<<<<<<<<<<<< + * weight_tostring(weight))) + * self._check_weight() + */ + __pyx_v_self->_weight.reset(new fst::script::WeightClass(__pyx_t_1, __pyx_t_2)); + + /* "pywrapfst.pyx":384 + * self._weight.reset(new fst.WeightClass(tostring(weight_type), + * weight_tostring(weight))) + * self._check_weight() # <<<<<<<<<<<<<< + * + * cdef void _check_weight(self) except *: + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_weight"); + __PYX_ERR(0, 384, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_self->__pyx_vtab)->_check_weight(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 384, __pyx_L1_error) + + /* "pywrapfst.pyx":381 + * return float(self.to_string()) + * + * def __init__(self, weight_type, weight): # <<<<<<<<<<<<<< + * self._weight.reset(new fst.WeightClass(tostring(weight_type), + * weight_tostring(weight))) + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst.Weight.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":386 + * self._check_weight() + * + * cdef void _check_weight(self) except *: # <<<<<<<<<<<<<< + * if self.type() == b"none": + * raise FstArgError("Weight type not found") + */ + +static void __pyx_f_9pywrapfst_6Weight__check_weight(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("_check_weight", 0); + + /* "pywrapfst.pyx":387 + * + * cdef void _check_weight(self) except *: + * if self.type() == b"none": # <<<<<<<<<<<<<< + * raise FstArgError("Weight type not found") + * if self.to_string() == b"BadNumber": + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "type"); + __PYX_ERR(0, 387, __pyx_L1_error) + } + __pyx_t_1 = ((((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_self->__pyx_vtab)->type(__pyx_v_self, 0) == ((char *)"none")) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":388 + * cdef void _check_weight(self) except *: + * if self.type() == b"none": + * raise FstArgError("Weight type not found") # <<<<<<<<<<<<<< + * if self.to_string() == b"BadNumber": + * raise FstBadWeightError("Invalid weight") + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 388, __pyx_L1_error) + + /* "pywrapfst.pyx":387 + * + * cdef void _check_weight(self) except *: + * if self.type() == b"none": # <<<<<<<<<<<<<< + * raise FstArgError("Weight type not found") + * if self.to_string() == b"BadNumber": + */ + } + + /* "pywrapfst.pyx":389 + * if self.type() == b"none": + * raise FstArgError("Weight type not found") + * if self.to_string() == b"BadNumber": # <<<<<<<<<<<<<< + * raise FstBadWeightError("Invalid weight") + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "to_string"); + __PYX_ERR(0, 389, __pyx_L1_error) + } + __pyx_t_1 = ((((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_self->__pyx_vtab)->to_string(__pyx_v_self, 0) == ((char *)"BadNumber")) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":390 + * raise FstArgError("Weight type not found") + * if self.to_string() == b"BadNumber": + * raise FstBadWeightError("Invalid weight") # <<<<<<<<<<<<<< + * + * cpdef Weight copy(self): + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstBadWeightError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 390, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 390, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 390, __pyx_L1_error) + + /* "pywrapfst.pyx":389 + * if self.type() == b"none": + * raise FstArgError("Weight type not found") + * if self.to_string() == b"BadNumber": # <<<<<<<<<<<<<< + * raise FstBadWeightError("Invalid weight") + * + */ + } + + /* "pywrapfst.pyx":386 + * self._check_weight() + * + * cdef void _check_weight(self) except *: # <<<<<<<<<<<<<< + * if self.type() == b"none": + * raise FstArgError("Weight type not found") + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pywrapfst.Weight._check_weight", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":392 + * raise FstBadWeightError("Invalid weight") + * + * cpdef Weight copy(self): # <<<<<<<<<<<<<< + * """ + * copy(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_6Weight_9copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst_6Weight_copy(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self, int __pyx_skip_dispatch) { + struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0; + struct __pyx_obj_9pywrapfst_Weight *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("copy", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_copy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 392, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_6Weight_9copy)) { + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 392, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 392, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pywrapfst_Weight))))) __PYX_ERR(0, 392, __pyx_L1_error) + __pyx_r = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_2); + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":398 + * Returns a copy of the Weight. + * """ + * cdef Weight result = Weight.__new__(Weight) # <<<<<<<<<<<<<< + * result._weight.reset(new fst.WeightClass(deref(self._weight))) + * return result + */ + __pyx_t_1 = __pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 398, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_Weight)))) __PYX_ERR(0, 398, __pyx_L1_error) + __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pywrapfst.pyx":399 + * """ + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(deref(self._weight))) # <<<<<<<<<<<<<< + * return result + * + */ + if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 399, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 399, __pyx_L1_error) + } + __pyx_v_result->_weight.reset(new fst::script::WeightClass((*__pyx_v_self->_weight))); + + /* "pywrapfst.pyx":400 + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(deref(self._weight))) + * return result # <<<<<<<<<<<<<< + * + * # To get around the inability to declare cdef class methods, we define the + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "pywrapfst.pyx":392 + * raise FstBadWeightError("Invalid weight") + * + * cpdef Weight copy(self): # <<<<<<<<<<<<<< + * """ + * copy(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pywrapfst.Weight.copy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_6Weight_9copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_6Weight_8copy[] = "\n copy(self)\n\n Returns a copy of the Weight.\n "; +static PyObject *__pyx_pw_9pywrapfst_6Weight_9copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("copy (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_6Weight_8copy(((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_6Weight_8copy(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("copy", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_6Weight_copy(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 392, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Weight.copy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":406 + * + * @classmethod + * def Zero(cls, weight_type): # <<<<<<<<<<<<<< + * """ + * Weight.Zero(weight_type) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_6Weight_11Zero(PyObject *__pyx_v_cls, PyObject *__pyx_v_weight_type); /*proto*/ +static char __pyx_doc_9pywrapfst_6Weight_10Zero[] = "\n Weight.Zero(weight_type)\n\n Constructs semiring zero.\n "; +static PyObject *__pyx_pw_9pywrapfst_6Weight_11Zero(PyObject *__pyx_v_cls, PyObject *__pyx_v_weight_type) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("Zero (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_6Weight_10Zero(((PyTypeObject*)__pyx_v_cls), ((PyObject *)__pyx_v_weight_type)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_6Weight_10Zero(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_weight_type) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("Zero", 0); + + /* "pywrapfst.pyx":412 + * Constructs semiring zero. + * """ + * return _Zero(weight_type) # <<<<<<<<<<<<<< + * + * @classmethod + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__Zero(__pyx_v_weight_type)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":406 + * + * @classmethod + * def Zero(cls, weight_type): # <<<<<<<<<<<<<< + * """ + * Weight.Zero(weight_type) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Weight.Zero", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":415 + * + * @classmethod + * def One(cls, weight_type): # <<<<<<<<<<<<<< + * """ + * Weight.One(weight_type) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_6Weight_13One(PyObject *__pyx_v_cls, PyObject *__pyx_v_weight_type); /*proto*/ +static char __pyx_doc_9pywrapfst_6Weight_12One[] = "\n Weight.One(weight_type)\n\n Constructs semiring One.\n "; +static PyObject *__pyx_pw_9pywrapfst_6Weight_13One(PyObject *__pyx_v_cls, PyObject *__pyx_v_weight_type) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("One (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_6Weight_12One(((PyTypeObject*)__pyx_v_cls), ((PyObject *)__pyx_v_weight_type)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_6Weight_12One(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_weight_type) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("One", 0); + + /* "pywrapfst.pyx":421 + * Constructs semiring One. + * """ + * return _One(weight_type) # <<<<<<<<<<<<<< + * + * @classmethod + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__One(__pyx_v_weight_type)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":415 + * + * @classmethod + * def One(cls, weight_type): # <<<<<<<<<<<<<< + * """ + * Weight.One(weight_type) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Weight.One", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":424 + * + * @classmethod + * def NoWeight(cls, weight_type): # <<<<<<<<<<<<<< + * """ + * Weight.NoWeight(weight_type) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_6Weight_15NoWeight(PyObject *__pyx_v_cls, PyObject *__pyx_v_weight_type); /*proto*/ +static char __pyx_doc_9pywrapfst_6Weight_14NoWeight[] = "\n Weight.NoWeight(weight_type)\n\n Constructs a non-member weight in the semiring.\n "; +static PyObject *__pyx_pw_9pywrapfst_6Weight_15NoWeight(PyObject *__pyx_v_cls, PyObject *__pyx_v_weight_type) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("NoWeight (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_6Weight_14NoWeight(((PyTypeObject*)__pyx_v_cls), ((PyObject *)__pyx_v_weight_type)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_6Weight_14NoWeight(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_weight_type) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("NoWeight", 0); + + /* "pywrapfst.pyx":430 + * Constructs a non-member weight in the semiring. + * """ + * return _NoWeight(weight_type) # <<<<<<<<<<<<<< + * + * def __eq__(Weight w1, Weight w2): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__NoWeight(__pyx_v_weight_type)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 430, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":424 + * + * @classmethod + * def NoWeight(cls, weight_type): # <<<<<<<<<<<<<< + * """ + * Weight.NoWeight(weight_type) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Weight.NoWeight", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":432 + * return _NoWeight(weight_type) + * + * def __eq__(Weight w1, Weight w2): # <<<<<<<<<<<<<< + * return fst.Eq(deref(w1._weight), deref(w2._weight)) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_6Weight_17__eq__(PyObject *__pyx_v_w1, PyObject *__pyx_v_w2); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_6Weight_17__eq__(PyObject *__pyx_v_w1, PyObject *__pyx_v_w2) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_w2), __pyx_ptype_9pywrapfst_Weight, 1, "w2", 0))) __PYX_ERR(0, 432, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_6Weight_16__eq__(((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_w1), ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_w2)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_6Weight_16__eq__(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_w1, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_w2) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__eq__", 0); + + /* "pywrapfst.pyx":433 + * + * def __eq__(Weight w1, Weight w2): + * return fst.Eq(deref(w1._weight), deref(w2._weight)) # <<<<<<<<<<<<<< + * + * def __ne__(Weight w1, Weight w2): + */ + __Pyx_XDECREF(__pyx_r); + if (unlikely(((PyObject *)__pyx_v_w1) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 433, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_w2) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 433, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_PyBool_FromLong(operator==((*__pyx_v_w1->_weight), (*__pyx_v_w2->_weight))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 433, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":432 + * return _NoWeight(weight_type) + * + * def __eq__(Weight w1, Weight w2): # <<<<<<<<<<<<<< + * return fst.Eq(deref(w1._weight), deref(w2._weight)) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Weight.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":435 + * return fst.Eq(deref(w1._weight), deref(w2._weight)) + * + * def __ne__(Weight w1, Weight w2): # <<<<<<<<<<<<<< + * return not w1 == w2 + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_6Weight_19__ne__(PyObject *__pyx_v_w1, PyObject *__pyx_v_w2); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_6Weight_19__ne__(PyObject *__pyx_v_w1, PyObject *__pyx_v_w2) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__ne__ (wrapper)", 0); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_w2), __pyx_ptype_9pywrapfst_Weight, 1, "w2", 0))) __PYX_ERR(0, 435, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_6Weight_18__ne__(((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_w1), ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_w2)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_6Weight_18__ne__(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_w1, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_w2) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + __Pyx_RefNannySetupContext("__ne__", 0); + + /* "pywrapfst.pyx":436 + * + * def __ne__(Weight w1, Weight w2): + * return not w1 == w2 # <<<<<<<<<<<<<< + * + * cpdef string to_string(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyObject_RichCompare(((PyObject *)__pyx_v_w1), ((PyObject *)__pyx_v_w2), Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 436, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 436, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyBool_FromLong((!__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 436, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":435 + * return fst.Eq(deref(w1._weight), deref(w2._weight)) + * + * def __ne__(Weight w1, Weight w2): # <<<<<<<<<<<<<< + * return not w1 == w2 + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Weight.__ne__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":438 + * return not w1 == w2 + * + * cpdef string to_string(self): # <<<<<<<<<<<<<< + * return self._weight.get().ToString() + * + */ + +static PyObject *__pyx_pw_9pywrapfst_6Weight_21to_string(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static std::string __pyx_f_9pywrapfst_6Weight_to_string(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self, int __pyx_skip_dispatch) { + std::string __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + std::string __pyx_t_5; + __Pyx_RefNannySetupContext("to_string", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_to_string); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 438, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_6Weight_21to_string)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 438, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 438, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 438, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":439 + * + * cpdef string to_string(self): + * return self._weight.get().ToString() # <<<<<<<<<<<<<< + * + * cpdef string type(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 439, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_weight.get()->ToString(); + goto __pyx_L0; + + /* "pywrapfst.pyx":438 + * return not w1 == w2 + * + * cpdef string to_string(self): # <<<<<<<<<<<<<< + * return self._weight.get().ToString() + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.Weight.to_string", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_6Weight_21to_string(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_6Weight_21to_string(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("to_string (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_6Weight_20to_string(((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_6Weight_20to_string(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("to_string", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_6Weight_to_string(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 438, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Weight.to_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":441 + * return self._weight.get().ToString() + * + * cpdef string type(self): # <<<<<<<<<<<<<< + * """type(self) + * + */ + +static PyObject *__pyx_pw_9pywrapfst_6Weight_23type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static std::string __pyx_f_9pywrapfst_6Weight_type(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self, int __pyx_skip_dispatch) { + std::string __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + std::string __pyx_t_5; + __Pyx_RefNannySetupContext("type", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 441, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_6Weight_23type)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 441, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 441, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 441, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":446 + * Returns a string indicating the weight type. + * """ + * return self._weight.get().Type() # <<<<<<<<<<<<<< + * + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 446, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_weight.get()->Type(); + goto __pyx_L0; + + /* "pywrapfst.pyx":441 + * return self._weight.get().ToString() + * + * cpdef string type(self): # <<<<<<<<<<<<<< + * """type(self) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.Weight.type", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_6Weight_23type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_6Weight_22type[] = "type(self)\n\n Returns a string indicating the weight type.\n "; +static PyObject *__pyx_pw_9pywrapfst_6Weight_23type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("type (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_6Weight_22type(((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_6Weight_22type(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("type", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_6Weight_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 441, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Weight.type", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._weight cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_6Weight_25__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_6Weight_25__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_6Weight_24__reduce_cython__(((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_6Weight_24__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._weight cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._weight cannot be converted to a Python object for pickling") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._weight cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Weight.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._weight cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._weight cannot be converted to a Python object for pickling") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_6Weight_27__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_6Weight_27__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_6Weight_26__setstate_cython__(((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_6Weight_26__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError("self._weight cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._weight cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._weight cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._weight cannot be converted to a Python object for pickling") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Weight.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":449 + * + * + * cdef Weight _plus(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.Plus(deref(lhs._weight), + */ + +static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__plus(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs) { + struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0; + struct __pyx_obj_9pywrapfst_Weight *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_plus", 0); + + /* "pywrapfst.pyx":450 + * + * cdef Weight _plus(Weight lhs, Weight rhs): + * cdef Weight result = Weight.__new__(Weight) # <<<<<<<<<<<<<< + * result._weight.reset(new fst.WeightClass(fst.Plus(deref(lhs._weight), + * deref(rhs._weight)))) + */ + __pyx_t_1 = __pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 450, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_Weight)))) __PYX_ERR(0, 450, __pyx_L1_error) + __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pywrapfst.pyx":451 + * cdef Weight _plus(Weight lhs, Weight rhs): + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.Plus(deref(lhs._weight), # <<<<<<<<<<<<<< + * deref(rhs._weight)))) + * return result + */ + if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 451, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_lhs) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 451, __pyx_L1_error) + } + + /* "pywrapfst.pyx":452 + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.Plus(deref(lhs._weight), + * deref(rhs._weight)))) # <<<<<<<<<<<<<< + * return result + * + */ + if (unlikely(((PyObject *)__pyx_v_rhs) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 452, __pyx_L1_error) + } + + /* "pywrapfst.pyx":451 + * cdef Weight _plus(Weight lhs, Weight rhs): + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.Plus(deref(lhs._weight), # <<<<<<<<<<<<<< + * deref(rhs._weight)))) + * return result + */ + __pyx_v_result->_weight.reset(new fst::script::WeightClass(fst::script::Plus((*__pyx_v_lhs->_weight), (*__pyx_v_rhs->_weight)))); + + /* "pywrapfst.pyx":453 + * result._weight.reset(new fst.WeightClass(fst.Plus(deref(lhs._weight), + * deref(rhs._weight)))) + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "pywrapfst.pyx":449 + * + * + * cdef Weight _plus(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.Plus(deref(lhs._weight), + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._plus", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":456 + * + * + * def plus(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< + * """ + * plus(lhs, rhs) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_1plus(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_plus[] = "\n plus(lhs, rhs)\n\n Computes the sum of two Weights in the same semiring.\n\n This function computes lhs \\oplus rhs, raising an exception if lhs and rhs\n are not in the same semiring.\n\n Args:\n lhs: Left-hand side Weight.\n rhs: Right-hand side Weight.\n\n Returns:\n A Weight object.\n\n Raises:\n FstArgError: Weight type not found (or not in same semiring).\n FstBadWeightError: invalid weight.\n "; +static PyMethodDef __pyx_mdef_9pywrapfst_1plus = {"plus", (PyCFunction)__pyx_pw_9pywrapfst_1plus, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_plus}; +static PyObject *__pyx_pw_9pywrapfst_1plus(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs = 0; + struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("plus (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_lhs,&__pyx_n_s_rhs,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_lhs)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_rhs)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("plus", 1, 2, 2, 1); __PYX_ERR(0, 456, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "plus") < 0)) __PYX_ERR(0, 456, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_lhs = ((struct __pyx_obj_9pywrapfst_Weight *)values[0]); + __pyx_v_rhs = ((struct __pyx_obj_9pywrapfst_Weight *)values[1]); + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("plus", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 456, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.plus", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_lhs), __pyx_ptype_9pywrapfst_Weight, 1, "lhs", 0))) __PYX_ERR(0, 456, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_rhs), __pyx_ptype_9pywrapfst_Weight, 1, "rhs", 0))) __PYX_ERR(0, 456, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_plus(__pyx_self, __pyx_v_lhs, __pyx_v_rhs); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_plus(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs) { + struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("plus", 0); + + /* "pywrapfst.pyx":476 + * FstBadWeightError: invalid weight. + * """ + * cdef Weight result = _plus(lhs, rhs) # <<<<<<<<<<<<<< + * result._check_weight() + * return result + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__plus(__pyx_v_lhs, __pyx_v_rhs)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pywrapfst.pyx":477 + * """ + * cdef Weight result = _plus(lhs, rhs) + * result._check_weight() # <<<<<<<<<<<<<< + * return result + * + */ + if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_weight"); + __PYX_ERR(0, 477, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_result->__pyx_vtab)->_check_weight(__pyx_v_result); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 477, __pyx_L1_error) + + /* "pywrapfst.pyx":478 + * cdef Weight result = _plus(lhs, rhs) + * result._check_weight() + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "pywrapfst.pyx":456 + * + * + * def plus(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< + * """ + * plus(lhs, rhs) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.plus", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":481 + * + * + * cdef Weight _times(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.Times(deref(lhs._weight), + */ + +static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__times(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs) { + struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0; + struct __pyx_obj_9pywrapfst_Weight *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_times", 0); + + /* "pywrapfst.pyx":482 + * + * cdef Weight _times(Weight lhs, Weight rhs): + * cdef Weight result = Weight.__new__(Weight) # <<<<<<<<<<<<<< + * result._weight.reset(new fst.WeightClass(fst.Times(deref(lhs._weight), + * deref(rhs._weight)))) + */ + __pyx_t_1 = __pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_Weight)))) __PYX_ERR(0, 482, __pyx_L1_error) + __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pywrapfst.pyx":483 + * cdef Weight _times(Weight lhs, Weight rhs): + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.Times(deref(lhs._weight), # <<<<<<<<<<<<<< + * deref(rhs._weight)))) + * return result + */ + if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 483, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_lhs) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 483, __pyx_L1_error) + } + + /* "pywrapfst.pyx":484 + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.Times(deref(lhs._weight), + * deref(rhs._weight)))) # <<<<<<<<<<<<<< + * return result + * + */ + if (unlikely(((PyObject *)__pyx_v_rhs) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 484, __pyx_L1_error) + } + + /* "pywrapfst.pyx":483 + * cdef Weight _times(Weight lhs, Weight rhs): + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.Times(deref(lhs._weight), # <<<<<<<<<<<<<< + * deref(rhs._weight)))) + * return result + */ + __pyx_v_result->_weight.reset(new fst::script::WeightClass(fst::script::Times((*__pyx_v_lhs->_weight), (*__pyx_v_rhs->_weight)))); + + /* "pywrapfst.pyx":485 + * result._weight.reset(new fst.WeightClass(fst.Times(deref(lhs._weight), + * deref(rhs._weight)))) + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "pywrapfst.pyx":481 + * + * + * cdef Weight _times(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.Times(deref(lhs._weight), + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._times", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":488 + * + * + * def times(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< + * """ + * times(lhs, rhs) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_3times(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_2times[] = "\n times(lhs, rhs)\n\n Computes the product of two Weights in the same semiring.\n\n This function computes lhs \\otimes rhs, raising an exception if lhs and rhs\n are not in the same semiring.\n\n Args:\n lhs: Left-hand side Weight.\n rhs: Right-hand side Weight.\n\n Returns:\n A Weight object.\n\n Raises:\n FstArgError: Weight type not found (or not in same semiring).\n FstBadWeightError: Invalid weight.\n "; +static PyMethodDef __pyx_mdef_9pywrapfst_3times = {"times", (PyCFunction)__pyx_pw_9pywrapfst_3times, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_2times}; +static PyObject *__pyx_pw_9pywrapfst_3times(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs = 0; + struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("times (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_lhs,&__pyx_n_s_rhs,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_lhs)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_rhs)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("times", 1, 2, 2, 1); __PYX_ERR(0, 488, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "times") < 0)) __PYX_ERR(0, 488, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_lhs = ((struct __pyx_obj_9pywrapfst_Weight *)values[0]); + __pyx_v_rhs = ((struct __pyx_obj_9pywrapfst_Weight *)values[1]); + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("times", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 488, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.times", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_lhs), __pyx_ptype_9pywrapfst_Weight, 1, "lhs", 0))) __PYX_ERR(0, 488, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_rhs), __pyx_ptype_9pywrapfst_Weight, 1, "rhs", 0))) __PYX_ERR(0, 488, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_2times(__pyx_self, __pyx_v_lhs, __pyx_v_rhs); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_2times(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs) { + struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("times", 0); + + /* "pywrapfst.pyx":508 + * FstBadWeightError: Invalid weight. + * """ + * cdef Weight result = _times(lhs, rhs) # <<<<<<<<<<<<<< + * result._check_weight() + * return result + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__times(__pyx_v_lhs, __pyx_v_rhs)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 508, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pywrapfst.pyx":509 + * """ + * cdef Weight result = _times(lhs, rhs) + * result._check_weight() # <<<<<<<<<<<<<< + * return result + * + */ + if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_weight"); + __PYX_ERR(0, 509, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_result->__pyx_vtab)->_check_weight(__pyx_v_result); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 509, __pyx_L1_error) + + /* "pywrapfst.pyx":510 + * cdef Weight result = _times(lhs, rhs) + * result._check_weight() + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "pywrapfst.pyx":488 + * + * + * def times(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< + * """ + * times(lhs, rhs) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.times", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":513 + * + * + * cdef Weight _divide(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.Divide(deref(lhs._weight), + */ + +static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__divide(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs) { + struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0; + struct __pyx_obj_9pywrapfst_Weight *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_divide", 0); + + /* "pywrapfst.pyx":514 + * + * cdef Weight _divide(Weight lhs, Weight rhs): + * cdef Weight result = Weight.__new__(Weight) # <<<<<<<<<<<<<< + * result._weight.reset(new fst.WeightClass(fst.Divide(deref(lhs._weight), + * deref(rhs._weight)))) + */ + __pyx_t_1 = __pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_Weight)))) __PYX_ERR(0, 514, __pyx_L1_error) + __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pywrapfst.pyx":515 + * cdef Weight _divide(Weight lhs, Weight rhs): + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.Divide(deref(lhs._weight), # <<<<<<<<<<<<<< + * deref(rhs._weight)))) + * return result + */ + if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 515, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_lhs) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 515, __pyx_L1_error) + } + + /* "pywrapfst.pyx":516 + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.Divide(deref(lhs._weight), + * deref(rhs._weight)))) # <<<<<<<<<<<<<< + * return result + * + */ + if (unlikely(((PyObject *)__pyx_v_rhs) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 516, __pyx_L1_error) + } + + /* "pywrapfst.pyx":515 + * cdef Weight _divide(Weight lhs, Weight rhs): + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.Divide(deref(lhs._weight), # <<<<<<<<<<<<<< + * deref(rhs._weight)))) + * return result + */ + __pyx_v_result->_weight.reset(new fst::script::WeightClass(fst::script::Divide((*__pyx_v_lhs->_weight), (*__pyx_v_rhs->_weight)))); + + /* "pywrapfst.pyx":517 + * result._weight.reset(new fst.WeightClass(fst.Divide(deref(lhs._weight), + * deref(rhs._weight)))) + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "pywrapfst.pyx":513 + * + * + * cdef Weight _divide(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.Divide(deref(lhs._weight), + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._divide", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":520 + * + * + * def divide(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< + * """ + * divide(lhs, rhs) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_5divide(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_4divide[] = "\n divide(lhs, rhs)\n\n Computes the quotient of two Weights in the same semiring.\n\n This function computes lhs \\oslash rhs, raising an exception if lhs and rhs\n are not in the same semiring. As there is no way to specify whether to use\n left vs. right division, this assumes a commutative semiring in which these\n are equivalent operations.\n\n Args:\n lhs: Left-hand side Weight.\n rhs: Right-hand side Weight.\n\n Returns:\n A Weight object.\n\n Raises:\n FstArgError: Weight type not found (or not in same semiring).\n FstBadWeightError: Invalid weight.\n "; +static PyMethodDef __pyx_mdef_9pywrapfst_5divide = {"divide", (PyCFunction)__pyx_pw_9pywrapfst_5divide, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_4divide}; +static PyObject *__pyx_pw_9pywrapfst_5divide(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs = 0; + struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("divide (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_lhs,&__pyx_n_s_rhs,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_lhs)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_rhs)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("divide", 1, 2, 2, 1); __PYX_ERR(0, 520, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "divide") < 0)) __PYX_ERR(0, 520, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_lhs = ((struct __pyx_obj_9pywrapfst_Weight *)values[0]); + __pyx_v_rhs = ((struct __pyx_obj_9pywrapfst_Weight *)values[1]); + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("divide", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 520, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.divide", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_lhs), __pyx_ptype_9pywrapfst_Weight, 1, "lhs", 0))) __PYX_ERR(0, 520, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_rhs), __pyx_ptype_9pywrapfst_Weight, 1, "rhs", 0))) __PYX_ERR(0, 520, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_4divide(__pyx_self, __pyx_v_lhs, __pyx_v_rhs); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4divide(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs) { + struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("divide", 0); + + /* "pywrapfst.pyx":542 + * FstBadWeightError: Invalid weight. + * """ + * cdef Weight result = _divide(lhs, rhs) # <<<<<<<<<<<<<< + * result._check_weight() + * return result + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__divide(__pyx_v_lhs, __pyx_v_rhs)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 542, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pywrapfst.pyx":543 + * """ + * cdef Weight result = _divide(lhs, rhs) + * result._check_weight() # <<<<<<<<<<<<<< + * return result + * + */ + if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_weight"); + __PYX_ERR(0, 543, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_result->__pyx_vtab)->_check_weight(__pyx_v_result); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 543, __pyx_L1_error) + + /* "pywrapfst.pyx":544 + * cdef Weight result = _divide(lhs, rhs) + * result._check_weight() + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "pywrapfst.pyx":520 + * + * + * def divide(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< + * """ + * divide(lhs, rhs) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.divide", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":547 + * + * + * cdef Weight _power(Weight w, size_t n): # <<<<<<<<<<<<<< + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.Power(deref(w._weight), n))) + */ + +static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__power(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_w, size_t __pyx_v_n) { + struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0; + struct __pyx_obj_9pywrapfst_Weight *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_power", 0); + + /* "pywrapfst.pyx":548 + * + * cdef Weight _power(Weight w, size_t n): + * cdef Weight result = Weight.__new__(Weight) # <<<<<<<<<<<<<< + * result._weight.reset(new fst.WeightClass(fst.Power(deref(w._weight), n))) + * return result + */ + __pyx_t_1 = __pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 548, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_Weight)))) __PYX_ERR(0, 548, __pyx_L1_error) + __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pywrapfst.pyx":549 + * cdef Weight _power(Weight w, size_t n): + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.Power(deref(w._weight), n))) # <<<<<<<<<<<<<< + * return result + * + */ + if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 549, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_w) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 549, __pyx_L1_error) + } + __pyx_v_result->_weight.reset(new fst::script::WeightClass(fst::script::Power((*__pyx_v_w->_weight), __pyx_v_n))); + + /* "pywrapfst.pyx":550 + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.Power(deref(w._weight), n))) + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "pywrapfst.pyx":547 + * + * + * cdef Weight _power(Weight w, size_t n): # <<<<<<<<<<<<<< + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.Power(deref(w._weight), n))) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._power", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":553 + * + * + * def power(Weight w, size_t n): # <<<<<<<<<<<<<< + * """ + * power(lhs, rhs) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_7power(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_6power[] = "\n power(lhs, rhs)\n\n Computes the iterated product of a weight.\n\n Args:\n w: The weight.\n n: The power.\n\n Returns:\n A Weight object.\n\n Raises:\n FstArgError: Weight type not found (or not in same semiring).\n FstBadWeightError: Invalid weight.\n "; +static PyMethodDef __pyx_mdef_9pywrapfst_7power = {"power", (PyCFunction)__pyx_pw_9pywrapfst_7power, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_6power}; +static PyObject *__pyx_pw_9pywrapfst_7power(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst_Weight *__pyx_v_w = 0; + size_t __pyx_v_n; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("power (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_w,&__pyx_n_s_n,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_w)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_n)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("power", 1, 2, 2, 1); __PYX_ERR(0, 553, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "power") < 0)) __PYX_ERR(0, 553, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_w = ((struct __pyx_obj_9pywrapfst_Weight *)values[0]); + __pyx_v_n = __Pyx_PyInt_As_size_t(values[1]); if (unlikely((__pyx_v_n == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 553, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("power", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 553, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.power", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_w), __pyx_ptype_9pywrapfst_Weight, 1, "w", 0))) __PYX_ERR(0, 553, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_6power(__pyx_self, __pyx_v_w, __pyx_v_n); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_6power(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_w, size_t __pyx_v_n) { + struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("power", 0); + + /* "pywrapfst.pyx":570 + * FstBadWeightError: Invalid weight. + * """ + * cdef Weight result = _power(w, n) # <<<<<<<<<<<<<< + * result._check_weight() + * return result + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__power(__pyx_v_w, __pyx_v_n)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 570, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pywrapfst.pyx":571 + * """ + * cdef Weight result = _power(w, n) + * result._check_weight() # <<<<<<<<<<<<<< + * return result + * + */ + if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_weight"); + __PYX_ERR(0, 571, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_result->__pyx_vtab)->_check_weight(__pyx_v_result); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 571, __pyx_L1_error) + + /* "pywrapfst.pyx":572 + * cdef Weight result = _power(w, n) + * result._check_weight() + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "pywrapfst.pyx":553 + * + * + * def power(Weight w, size_t n): # <<<<<<<<<<<<<< + * """ + * power(lhs, rhs) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.power", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":575 + * + * + * cdef fst.WeightClass _get_WeightClass_or_Zero(const string &weight_type, # <<<<<<<<<<<<<< + * weight) except *: + * """Converts weight string to a WeightClass. + */ + +static fst::script::WeightClass __pyx_f_9pywrapfst__get_WeightClass_or_Zero(std::string const &__pyx_v_weight_type, PyObject *__pyx_v_weight) { + fst::script::WeightClass __pyx_v_result; + fst::script::WeightClass __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + std::string __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("_get_WeightClass_or_Zero", 0); + + /* "pywrapfst.pyx":593 + * """ + * cdef fst.WeightClass result + * if weight is None: # <<<<<<<<<<<<<< + * result = fst.WeightClass.Zero(weight_type) + * elif isinstance(weight, Weight): + */ + __pyx_t_1 = (__pyx_v_weight == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "pywrapfst.pyx":594 + * cdef fst.WeightClass result + * if weight is None: + * result = fst.WeightClass.Zero(weight_type) # <<<<<<<<<<<<<< + * elif isinstance(weight, Weight): + * result = deref( ( weight)._weight.get()) + */ + __pyx_v_result = fst::script::WeightClass::Zero(__pyx_v_weight_type); + + /* "pywrapfst.pyx":593 + * """ + * cdef fst.WeightClass result + * if weight is None: # <<<<<<<<<<<<<< + * result = fst.WeightClass.Zero(weight_type) + * elif isinstance(weight, Weight): + */ + goto __pyx_L3; + } + + /* "pywrapfst.pyx":595 + * if weight is None: + * result = fst.WeightClass.Zero(weight_type) + * elif isinstance(weight, Weight): # <<<<<<<<<<<<<< + * result = deref( ( weight)._weight.get()) + * else: + */ + __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_weight, __pyx_ptype_9pywrapfst_Weight); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":596 + * result = fst.WeightClass.Zero(weight_type) + * elif isinstance(weight, Weight): + * result = deref( ( weight)._weight.get()) # <<<<<<<<<<<<<< + * else: + * result = fst.WeightClass(weight_type, weight_tostring(weight)) + */ + if (unlikely(__pyx_v_weight == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 596, __pyx_L1_error) + } + __pyx_v_result = (*((fst::script::WeightClass *)((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_weight)->_weight.get())); + + /* "pywrapfst.pyx":595 + * if weight is None: + * result = fst.WeightClass.Zero(weight_type) + * elif isinstance(weight, Weight): # <<<<<<<<<<<<<< + * result = deref( ( weight)._weight.get()) + * else: + */ + goto __pyx_L3; + } + + /* "pywrapfst.pyx":598 + * result = deref( ( weight)._weight.get()) + * else: + * result = fst.WeightClass(weight_type, weight_tostring(weight)) # <<<<<<<<<<<<<< + * if result.ToString() == b"BadNumber": + * raise FstBadWeightError(weight_tostring(weight)) + */ + /*else*/ { + __pyx_t_3 = __pyx_f_9pywrapfst_weight_tostring(__pyx_v_weight, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 598, __pyx_L1_error) + __pyx_v_result = fst::script::WeightClass(__pyx_v_weight_type, __pyx_t_3); + + /* "pywrapfst.pyx":599 + * else: + * result = fst.WeightClass(weight_type, weight_tostring(weight)) + * if result.ToString() == b"BadNumber": # <<<<<<<<<<<<<< + * raise FstBadWeightError(weight_tostring(weight)) + * return result + */ + __pyx_t_1 = ((__pyx_v_result.ToString() == ((char *)"BadNumber")) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":600 + * result = fst.WeightClass(weight_type, weight_tostring(weight)) + * if result.ToString() == b"BadNumber": + * raise FstBadWeightError(weight_tostring(weight)) # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstBadWeightError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __pyx_f_9pywrapfst_weight_tostring(__pyx_v_weight, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 600, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_7) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 600, __pyx_L1_error) + + /* "pywrapfst.pyx":599 + * else: + * result = fst.WeightClass(weight_type, weight_tostring(weight)) + * if result.ToString() == b"BadNumber": # <<<<<<<<<<<<<< + * raise FstBadWeightError(weight_tostring(weight)) + * return result + */ + } + } + __pyx_L3:; + + /* "pywrapfst.pyx":601 + * if result.ToString() == b"BadNumber": + * raise FstBadWeightError(weight_tostring(weight)) + * return result # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "pywrapfst.pyx":575 + * + * + * cdef fst.WeightClass _get_WeightClass_or_Zero(const string &weight_type, # <<<<<<<<<<<<<< + * weight) except *: + * """Converts weight string to a WeightClass. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pywrapfst._get_WeightClass_or_Zero", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":604 + * + * + * cdef fst.WeightClass _get_WeightClass_or_One(const string &weight_type, # <<<<<<<<<<<<<< + * weight) except *: + * """Converts weight string to a WeightClass. + */ + +static fst::script::WeightClass __pyx_f_9pywrapfst__get_WeightClass_or_One(std::string const &__pyx_v_weight_type, PyObject *__pyx_v_weight) { + fst::script::WeightClass __pyx_v_result; + fst::script::WeightClass __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + std::string __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("_get_WeightClass_or_One", 0); + + /* "pywrapfst.pyx":622 + * """ + * cdef fst.WeightClass result + * if weight is None: # <<<<<<<<<<<<<< + * result = fst.WeightClass.One(weight_type) + * elif isinstance(weight, Weight): + */ + __pyx_t_1 = (__pyx_v_weight == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "pywrapfst.pyx":623 + * cdef fst.WeightClass result + * if weight is None: + * result = fst.WeightClass.One(weight_type) # <<<<<<<<<<<<<< + * elif isinstance(weight, Weight): + * result = deref( ( weight)._weight.get()) + */ + __pyx_v_result = fst::script::WeightClass::One(__pyx_v_weight_type); + + /* "pywrapfst.pyx":622 + * """ + * cdef fst.WeightClass result + * if weight is None: # <<<<<<<<<<<<<< + * result = fst.WeightClass.One(weight_type) + * elif isinstance(weight, Weight): + */ + goto __pyx_L3; + } + + /* "pywrapfst.pyx":624 + * if weight is None: + * result = fst.WeightClass.One(weight_type) + * elif isinstance(weight, Weight): # <<<<<<<<<<<<<< + * result = deref( ( weight)._weight.get()) + * else: + */ + __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_weight, __pyx_ptype_9pywrapfst_Weight); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":625 + * result = fst.WeightClass.One(weight_type) + * elif isinstance(weight, Weight): + * result = deref( ( weight)._weight.get()) # <<<<<<<<<<<<<< + * else: + * result = fst.WeightClass(weight_type, weight_tostring(weight)) + */ + if (unlikely(__pyx_v_weight == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 625, __pyx_L1_error) + } + __pyx_v_result = (*((fst::script::WeightClass *)((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_weight)->_weight.get())); + + /* "pywrapfst.pyx":624 + * if weight is None: + * result = fst.WeightClass.One(weight_type) + * elif isinstance(weight, Weight): # <<<<<<<<<<<<<< + * result = deref( ( weight)._weight.get()) + * else: + */ + goto __pyx_L3; + } + + /* "pywrapfst.pyx":627 + * result = deref( ( weight)._weight.get()) + * else: + * result = fst.WeightClass(weight_type, weight_tostring(weight)) # <<<<<<<<<<<<<< + * if result.ToString() == b"BadNumber": + * raise FstBadWeightError(weight_tostring(weight)) + */ + /*else*/ { + __pyx_t_3 = __pyx_f_9pywrapfst_weight_tostring(__pyx_v_weight, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 627, __pyx_L1_error) + __pyx_v_result = fst::script::WeightClass(__pyx_v_weight_type, __pyx_t_3); + + /* "pywrapfst.pyx":628 + * else: + * result = fst.WeightClass(weight_type, weight_tostring(weight)) + * if result.ToString() == b"BadNumber": # <<<<<<<<<<<<<< + * raise FstBadWeightError(weight_tostring(weight)) + * return result + */ + __pyx_t_1 = ((__pyx_v_result.ToString() == ((char *)"BadNumber")) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":629 + * result = fst.WeightClass(weight_type, weight_tostring(weight)) + * if result.ToString() == b"BadNumber": + * raise FstBadWeightError(weight_tostring(weight)) # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstBadWeightError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 629, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __pyx_f_9pywrapfst_weight_tostring(__pyx_v_weight, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 629, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 629, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_7) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 629, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 629, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 629, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 629, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 629, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 629, __pyx_L1_error) + + /* "pywrapfst.pyx":628 + * else: + * result = fst.WeightClass(weight_type, weight_tostring(weight)) + * if result.ToString() == b"BadNumber": # <<<<<<<<<<<<<< + * raise FstBadWeightError(weight_tostring(weight)) + * return result + */ + } + } + __pyx_L3:; + + /* "pywrapfst.pyx":630 + * if result.ToString() == b"BadNumber": + * raise FstBadWeightError(weight_tostring(weight)) + * return result # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "pywrapfst.pyx":604 + * + * + * cdef fst.WeightClass _get_WeightClass_or_One(const string &weight_type, # <<<<<<<<<<<<<< + * weight) except *: + * """Converts weight string to a WeightClass. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pywrapfst._get_WeightClass_or_One", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":633 + * + * + * cdef Weight _Zero(weight_type): # <<<<<<<<<<<<<< + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.WeightClass.Zero( + */ + +static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__Zero(PyObject *__pyx_v_weight_type) { + struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0; + struct __pyx_obj_9pywrapfst_Weight *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + std::string __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("_Zero", 0); + + /* "pywrapfst.pyx":634 + * + * cdef Weight _Zero(weight_type): + * cdef Weight result = Weight.__new__(Weight) # <<<<<<<<<<<<<< + * result._weight.reset(new fst.WeightClass(fst.WeightClass.Zero( + * tostring(weight_type)))) + */ + __pyx_t_1 = __pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 634, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_Weight)))) __PYX_ERR(0, 634, __pyx_L1_error) + __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pywrapfst.pyx":635 + * cdef Weight _Zero(weight_type): + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.WeightClass.Zero( # <<<<<<<<<<<<<< + * tostring(weight_type)))) + * if result._weight.get().Type() == b"none": + */ + if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 635, __pyx_L1_error) + } + + /* "pywrapfst.pyx":636 + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.WeightClass.Zero( + * tostring(weight_type)))) # <<<<<<<<<<<<<< + * if result._weight.get().Type() == b"none": + * raise FstArgError("Weight type not found") + */ + __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_v_weight_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 636, __pyx_L1_error) + + /* "pywrapfst.pyx":635 + * cdef Weight _Zero(weight_type): + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.WeightClass.Zero( # <<<<<<<<<<<<<< + * tostring(weight_type)))) + * if result._weight.get().Type() == b"none": + */ + __pyx_v_result->_weight.reset(new fst::script::WeightClass(fst::script::WeightClass::Zero(__pyx_t_2))); + + /* "pywrapfst.pyx":637 + * result._weight.reset(new fst.WeightClass(fst.WeightClass.Zero( + * tostring(weight_type)))) + * if result._weight.get().Type() == b"none": # <<<<<<<<<<<<<< + * raise FstArgError("Weight type not found") + * return result + */ + if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 637, __pyx_L1_error) + } + __pyx_t_3 = ((__pyx_v_result->_weight.get()->Type() == ((char *)"none")) != 0); + if (__pyx_t_3) { + + /* "pywrapfst.pyx":638 + * tostring(weight_type)))) + * if result._weight.get().Type() == b"none": + * raise FstArgError("Weight type not found") # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 638, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 638, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 638, __pyx_L1_error) + + /* "pywrapfst.pyx":637 + * result._weight.reset(new fst.WeightClass(fst.WeightClass.Zero( + * tostring(weight_type)))) + * if result._weight.get().Type() == b"none": # <<<<<<<<<<<<<< + * raise FstArgError("Weight type not found") + * return result + */ + } + + /* "pywrapfst.pyx":639 + * if result._weight.get().Type() == b"none": + * raise FstArgError("Weight type not found") + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "pywrapfst.pyx":633 + * + * + * cdef Weight _Zero(weight_type): # <<<<<<<<<<<<<< + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass(fst.WeightClass.Zero( + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pywrapfst._Zero", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":642 + * + * + * cdef Weight _One(weight_type): # <<<<<<<<<<<<<< + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass( + */ + +static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__One(PyObject *__pyx_v_weight_type) { + struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0; + struct __pyx_obj_9pywrapfst_Weight *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + std::string __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("_One", 0); + + /* "pywrapfst.pyx":643 + * + * cdef Weight _One(weight_type): + * cdef Weight result = Weight.__new__(Weight) # <<<<<<<<<<<<<< + * result._weight.reset(new fst.WeightClass( + * fst.WeightClass.One(tostring(weight_type)))) + */ + __pyx_t_1 = __pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 643, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_Weight)))) __PYX_ERR(0, 643, __pyx_L1_error) + __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pywrapfst.pyx":644 + * cdef Weight _One(weight_type): + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass( # <<<<<<<<<<<<<< + * fst.WeightClass.One(tostring(weight_type)))) + * if result._weight.get().Type() == b"none": + */ + if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 644, __pyx_L1_error) + } + + /* "pywrapfst.pyx":645 + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass( + * fst.WeightClass.One(tostring(weight_type)))) # <<<<<<<<<<<<<< + * if result._weight.get().Type() == b"none": + * raise FstArgError("Weight type not found") + */ + __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_v_weight_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 645, __pyx_L1_error) + + /* "pywrapfst.pyx":644 + * cdef Weight _One(weight_type): + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass( # <<<<<<<<<<<<<< + * fst.WeightClass.One(tostring(weight_type)))) + * if result._weight.get().Type() == b"none": + */ + __pyx_v_result->_weight.reset(new fst::script::WeightClass(fst::script::WeightClass::One(__pyx_t_2))); + + /* "pywrapfst.pyx":646 + * result._weight.reset(new fst.WeightClass( + * fst.WeightClass.One(tostring(weight_type)))) + * if result._weight.get().Type() == b"none": # <<<<<<<<<<<<<< + * raise FstArgError("Weight type not found") + * return result + */ + if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 646, __pyx_L1_error) + } + __pyx_t_3 = ((__pyx_v_result->_weight.get()->Type() == ((char *)"none")) != 0); + if (__pyx_t_3) { + + /* "pywrapfst.pyx":647 + * fst.WeightClass.One(tostring(weight_type)))) + * if result._weight.get().Type() == b"none": + * raise FstArgError("Weight type not found") # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 647, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 647, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 647, __pyx_L1_error) + + /* "pywrapfst.pyx":646 + * result._weight.reset(new fst.WeightClass( + * fst.WeightClass.One(tostring(weight_type)))) + * if result._weight.get().Type() == b"none": # <<<<<<<<<<<<<< + * raise FstArgError("Weight type not found") + * return result + */ + } + + /* "pywrapfst.pyx":648 + * if result._weight.get().Type() == b"none": + * raise FstArgError("Weight type not found") + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "pywrapfst.pyx":642 + * + * + * cdef Weight _One(weight_type): # <<<<<<<<<<<<<< + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass( + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pywrapfst._One", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":651 + * + * + * cdef Weight _NoWeight(weight_type): # <<<<<<<<<<<<<< + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass( + */ + +static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__NoWeight(PyObject *__pyx_v_weight_type) { + struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0; + struct __pyx_obj_9pywrapfst_Weight *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + std::string __pyx_t_2; + __Pyx_RefNannySetupContext("_NoWeight", 0); + + /* "pywrapfst.pyx":652 + * + * cdef Weight _NoWeight(weight_type): + * cdef Weight result = Weight.__new__(Weight) # <<<<<<<<<<<<<< + * result._weight.reset(new fst.WeightClass( + * fst.WeightClass.NoWeight(tostring(weight_type)))) + */ + __pyx_t_1 = __pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 652, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_Weight)))) __PYX_ERR(0, 652, __pyx_L1_error) + __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pywrapfst.pyx":653 + * cdef Weight _NoWeight(weight_type): + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass( # <<<<<<<<<<<<<< + * fst.WeightClass.NoWeight(tostring(weight_type)))) + * return result + */ + if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 653, __pyx_L1_error) + } + + /* "pywrapfst.pyx":654 + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass( + * fst.WeightClass.NoWeight(tostring(weight_type)))) # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_v_weight_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 654, __pyx_L1_error) + + /* "pywrapfst.pyx":653 + * cdef Weight _NoWeight(weight_type): + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass( # <<<<<<<<<<<<<< + * fst.WeightClass.NoWeight(tostring(weight_type)))) + * return result + */ + __pyx_v_result->_weight.reset(new fst::script::WeightClass(fst::script::WeightClass::NoWeight(__pyx_t_2))); + + /* "pywrapfst.pyx":655 + * result._weight.reset(new fst.WeightClass( + * fst.WeightClass.NoWeight(tostring(weight_type)))) + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "pywrapfst.pyx":651 + * + * + * cdef Weight _NoWeight(weight_type): # <<<<<<<<<<<<<< + * cdef Weight result = Weight.__new__(Weight) + * result._weight.reset(new fst.WeightClass( + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._NoWeight", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":689 + * # Doing so will allow undefined behavior. + * + * def __init__(self): # <<<<<<<<<<<<<< + * raise FstDeletedConstructorError( + * "Cannot construct {}".format(self.__class__.__name__)) + */ + +/* Python wrapper */ +static int __pyx_pw_9pywrapfst_12_SymbolTable_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_9pywrapfst_12_SymbolTable_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} + if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; + __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable___init__(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pywrapfst_12_SymbolTable___init__(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "pywrapfst.pyx":690 + * + * def __init__(self): + * raise FstDeletedConstructorError( # <<<<<<<<<<<<<< + * "Cannot construct {}".format(self.__class__.__name__)) + * + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstDeletedConstructorError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 690, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "pywrapfst.pyx":691 + * def __init__(self): + * raise FstDeletedConstructorError( + * "Cannot construct {}".format(self.__class__.__name__)) # <<<<<<<<<<<<<< + * + * def __iter__(self): + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Cannot_construct, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 691, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 691, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 691, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 690, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 690, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 690, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 690, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 690, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 690, __pyx_L1_error) + + /* "pywrapfst.pyx":689 + * # Doing so will allow undefined behavior. + * + * def __init__(self): # <<<<<<<<<<<<<< + * raise FstDeletedConstructorError( + * "Cannot construct {}".format(self.__class__.__name__)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pywrapfst._SymbolTable.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":693 + * "Cannot construct {}".format(self.__class__.__name__)) + * + * def __iter__(self): # <<<<<<<<<<<<<< + * return SymbolTableIterator(self) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_3__iter__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_3__iter__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_2__iter__(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_2__iter__(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__iter__", 0); + + /* "pywrapfst.pyx":694 + * + * def __iter__(self): + * return SymbolTableIterator(self) # <<<<<<<<<<<<<< + * + * cpdef int64 available_key(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self)); + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pywrapfst_SymbolTableIterator), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":693 + * "Cannot construct {}".format(self.__class__.__name__)) + * + * def __iter__(self): # <<<<<<<<<<<<<< + * return SymbolTableIterator(self) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pywrapfst._SymbolTable.__iter__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":696 + * return SymbolTableIterator(self) + * + * cpdef int64 available_key(self): # <<<<<<<<<<<<<< + * """ + * available_key(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_5available_key(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_12_SymbolTable_available_key(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch) { + __pyx_t_10basictypes_int64 __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __pyx_t_10basictypes_int64 __pyx_t_5; + __Pyx_RefNannySetupContext("available_key", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_available_key); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 696, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_5available_key)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 696, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 696, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 696, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":702 + * Returns an integer indicating the next available key index in the table. + * """ + * return self._table.AvailableKey() # <<<<<<<<<<<<<< + * + * cpdef string checksum(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 702, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_table->AvailableKey(); + goto __pyx_L0; + + /* "pywrapfst.pyx":696 + * return SymbolTableIterator(self) + * + * cpdef int64 available_key(self): # <<<<<<<<<<<<<< + * """ + * available_key(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst._SymbolTable.available_key", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_5available_key(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_12_SymbolTable_4available_key[] = "\n available_key(self)\n\n Returns an integer indicating the next available key index in the table.\n "; +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_5available_key(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("available_key (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_4available_key(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_4available_key(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("available_key", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_f_9pywrapfst_12_SymbolTable_available_key(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 696, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._SymbolTable.available_key", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":704 + * return self._table.AvailableKey() + * + * cpdef string checksum(self): # <<<<<<<<<<<<<< + * """ + * checksum(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_7checksum(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static std::string __pyx_f_9pywrapfst_12_SymbolTable_checksum(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch) { + std::string __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + std::string __pyx_t_5; + __Pyx_RefNannySetupContext("checksum", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 704, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_7checksum)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 704, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 704, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 704, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":710 + * Returns a string indicating the label-agnostic MD5 checksum for the table. + * """ + * return self._table.CheckSum() # <<<<<<<<<<<<<< + * + * cpdef SymbolTable copy(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 710, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_table->CheckSum(); + goto __pyx_L0; + + /* "pywrapfst.pyx":704 + * return self._table.AvailableKey() + * + * cpdef string checksum(self): # <<<<<<<<<<<<<< + * """ + * checksum(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst._SymbolTable.checksum", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_7checksum(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_12_SymbolTable_6checksum[] = "\n checksum(self)\n\n Returns a string indicating the label-agnostic MD5 checksum for the table.\n "; +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_7checksum(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("checksum (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_6checksum(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_6checksum(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("checksum", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_12_SymbolTable_checksum(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 704, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._SymbolTable.checksum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":712 + * return self._table.CheckSum() + * + * cpdef SymbolTable copy(self): # <<<<<<<<<<<<<< + * """ + * copy(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_9copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst_12_SymbolTable_copy(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch) { + struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("copy", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_copy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 712, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_9copy)) { + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 712, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 712, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pywrapfst_SymbolTable))))) __PYX_ERR(0, 712, __pyx_L1_error) + __pyx_r = ((struct __pyx_obj_9pywrapfst_SymbolTable *)__pyx_t_2); + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":718 + * Returns a mutable copy of the SymbolTable. + * """ + * return _init_SymbolTable(self._table.Copy()) # <<<<<<<<<<<<<< + * + * def find(self, key): + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 718, __pyx_L1_error) + } + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_SymbolTable(__pyx_v_self->_table->Copy())); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 718, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = ((struct __pyx_obj_9pywrapfst_SymbolTable *)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":712 + * return self._table.CheckSum() + * + * cpdef SymbolTable copy(self): # <<<<<<<<<<<<<< + * """ + * copy(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pywrapfst._SymbolTable.copy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_9copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_12_SymbolTable_8copy[] = "\n copy(self)\n\n Returns a mutable copy of the SymbolTable.\n "; +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_9copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("copy (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_8copy(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_8copy(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("copy", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_12_SymbolTable_copy(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 712, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._SymbolTable.copy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":720 + * return _init_SymbolTable(self._table.Copy()) + * + * def find(self, key): # <<<<<<<<<<<<<< + * """ + * find(self, key) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_11find(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ +static char __pyx_doc_9pywrapfst_12_SymbolTable_10find[] = "\n find(self, key)\n\n Given a symbol or index, finds the other one.\n\n This method returns the index associated with a symbol key, or the symbol\n associated with a index key.\n\n Args:\n key: Either a string or an index.\n\n Returns:\n If the key is a string, the associated index or NO_LABEL if not found; if\n the key is an integer, the associated symbol or an empty string if\n not found.\n "; +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_11find(PyObject *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("find (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_10find(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self), ((PyObject *)__pyx_v_key)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_10find(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + std::string __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __pyx_t_10basictypes_int64 __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + __Pyx_RefNannySetupContext("find", 0); + + /* "pywrapfst.pyx":737 + * not found. + * """ + * try: # <<<<<<<<<<<<<< + * return self._table.FindIndex(tostring(key)) + * except FstArgError: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "pywrapfst.pyx":738 + * """ + * try: + * return self._table.FindIndex(tostring(key)) # <<<<<<<<<<<<<< + * except FstArgError: + * return self._table.FindSymbol(key) + */ + __Pyx_XDECREF(__pyx_r); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 738, __pyx_L3_error) + } + __pyx_t_4 = __pyx_f_9pywrapfst_tostring(__pyx_v_key, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 738, __pyx_L3_error) + __pyx_t_5 = __Pyx_PyInt_From_int64_t(__pyx_v_self->_table->Find(__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 738, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L7_try_return; + + /* "pywrapfst.pyx":737 + * not found. + * """ + * try: # <<<<<<<<<<<<<< + * return self._table.FindIndex(tostring(key)) + * except FstArgError: + */ + } + __pyx_L3_error:; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "pywrapfst.pyx":739 + * try: + * return self._table.FindIndex(tostring(key)) + * except FstArgError: # <<<<<<<<<<<<<< + * return self._table.FindSymbol(key) + * + */ + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 739, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__pyx_t_6) { + __Pyx_AddTraceback("pywrapfst._SymbolTable.find", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(0, 739, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_8); + + /* "pywrapfst.pyx":740 + * return self._table.FindIndex(tostring(key)) + * except FstArgError: + * return self._table.FindSymbol(key) # <<<<<<<<<<<<<< + * + * cpdef int64 get_nth_key(self, ssize_t pos) except *: + */ + __Pyx_XDECREF(__pyx_r); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 740, __pyx_L5_except_error) + } + __pyx_t_9 = __Pyx_PyInt_As_int64_t(__pyx_v_key); if (unlikely((__pyx_t_9 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 740, __pyx_L5_except_error) + __pyx_t_10 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_self->_table->Find(__pyx_t_9)); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 740, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_r = __pyx_t_10; + __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L6_except_return; + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "pywrapfst.pyx":737 + * not found. + * """ + * try: # <<<<<<<<<<<<<< + * return self._table.FindIndex(tostring(key)) + * except FstArgError: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L7_try_return:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L0; + __pyx_L6_except_return:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L0; + } + + /* "pywrapfst.pyx":720 + * return _init_SymbolTable(self._table.Copy()) + * + * def find(self, key): # <<<<<<<<<<<<<< + * """ + * find(self, key) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("pywrapfst._SymbolTable.find", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":742 + * return self._table.FindSymbol(key) + * + * cpdef int64 get_nth_key(self, ssize_t pos) except *: # <<<<<<<<<<<<<< + * """ + * get_nth_key(self, pos) + */ + +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_13get_nth_key(PyObject *__pyx_v_self, PyObject *__pyx_arg_pos); /*proto*/ +static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_12_SymbolTable_get_nth_key(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, Py_ssize_t __pyx_v_pos, int __pyx_skip_dispatch) { + __pyx_t_10basictypes_int64 __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + __pyx_t_10basictypes_int64 __pyx_t_7; + __Pyx_RefNannySetupContext("get_nth_key", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_nth_key); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 742, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_13get_nth_key)) { + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_pos); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 742, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 742, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 742, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 742, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 742, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 742, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_7 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_7 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 742, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_7; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":754 + * The integer index of the n-th key, or NO_LABEL if not found. + * """ + * return self._table.GetNthKey(pos) # <<<<<<<<<<<<<< + * + * cpdef string labeled_checksum(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 754, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_table->GetNthKey(__pyx_v_pos); + goto __pyx_L0; + + /* "pywrapfst.pyx":742 + * return self._table.FindSymbol(key) + * + * cpdef int64 get_nth_key(self, ssize_t pos) except *: # <<<<<<<<<<<<<< + * """ + * get_nth_key(self, pos) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pywrapfst._SymbolTable.get_nth_key", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_13get_nth_key(PyObject *__pyx_v_self, PyObject *__pyx_arg_pos); /*proto*/ +static char __pyx_doc_9pywrapfst_12_SymbolTable_12get_nth_key[] = "\n get_nth_key(self, pos)\n\n Retrieves the integer index of the n-th key in the table.\n\n Args:\n pos: The n-th key to retrieve.\n\n Returns:\n The integer index of the n-th key, or NO_LABEL if not found.\n "; +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_13get_nth_key(PyObject *__pyx_v_self, PyObject *__pyx_arg_pos) { + Py_ssize_t __pyx_v_pos; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_nth_key (wrapper)", 0); + assert(__pyx_arg_pos); { + __pyx_v_pos = PyInt_AsSsize_t(__pyx_arg_pos); if (unlikely((__pyx_v_pos == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 742, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._SymbolTable.get_nth_key", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_12get_nth_key(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self), ((Py_ssize_t)__pyx_v_pos)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_12get_nth_key(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, Py_ssize_t __pyx_v_pos) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __pyx_t_10basictypes_int64 __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("get_nth_key", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pywrapfst_12_SymbolTable_get_nth_key(__pyx_v_self, __pyx_v_pos, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 742, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_int64_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 742, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pywrapfst._SymbolTable.get_nth_key", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":756 + * return self._table.GetNthKey(pos) + * + * cpdef string labeled_checksum(self): # <<<<<<<<<<<<<< + * """ + * labeled_checksum(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_15labeled_checksum(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static std::string __pyx_f_9pywrapfst_12_SymbolTable_labeled_checksum(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch) { + std::string __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + std::string __pyx_t_5; + __Pyx_RefNannySetupContext("labeled_checksum", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_labeled_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 756, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_15labeled_checksum)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 756, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 756, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 756, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":762 + * Returns a string indicating the label-dependent MD5 checksum for the table. + * """ + * return self._table.LabeledCheckSum() # <<<<<<<<<<<<<< + * + * cpdef bool member(self, key): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 762, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_table->LabeledCheckSum(); + goto __pyx_L0; + + /* "pywrapfst.pyx":756 + * return self._table.GetNthKey(pos) + * + * cpdef string labeled_checksum(self): # <<<<<<<<<<<<<< + * """ + * labeled_checksum(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst._SymbolTable.labeled_checksum", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_15labeled_checksum(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_12_SymbolTable_14labeled_checksum[] = "\n labeled_checksum(self)\n\n Returns a string indicating the label-dependent MD5 checksum for the table.\n "; +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_15labeled_checksum(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("labeled_checksum (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_14labeled_checksum(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_14labeled_checksum(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("labeled_checksum", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_12_SymbolTable_labeled_checksum(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 756, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._SymbolTable.labeled_checksum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":764 + * return self._table.LabeledCheckSum() + * + * cpdef bool member(self, key): # <<<<<<<<<<<<<< + * """ + * member(self, key) + */ + +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_17member(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ +static bool __pyx_f_9pywrapfst_12_SymbolTable_member(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_key, int __pyx_skip_dispatch) { + bool __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + bool __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + std::string __pyx_t_10; + int __pyx_t_11; + __pyx_t_10basictypes_int64 __pyx_t_12; + __Pyx_RefNannySetupContext("member", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_member); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 764, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_17member)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 764, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_key}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 764, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_key}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 764, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 764, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_key); + __Pyx_GIVEREF(__pyx_v_key); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_key); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 764, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_6 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 764, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_6; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":780 + * Whether or not the key is present (as a string or a index) in the table. + * """ + * try: # <<<<<<<<<<<<<< + * return self._table.MemberSymbol(tostring(key)) + * except FstArgError: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + /*try:*/ { + + /* "pywrapfst.pyx":781 + * """ + * try: + * return self._table.MemberSymbol(tostring(key)) # <<<<<<<<<<<<<< + * except FstArgError: + * return self._table.MemberIndex(key) + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 781, __pyx_L3_error) + } + __pyx_t_10 = __pyx_f_9pywrapfst_tostring(__pyx_v_key, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 781, __pyx_L3_error) + __pyx_r = __pyx_v_self->_table->Member(__pyx_t_10); + goto __pyx_L7_try_return; + + /* "pywrapfst.pyx":780 + * Whether or not the key is present (as a string or a index) in the table. + * """ + * try: # <<<<<<<<<<<<<< + * return self._table.MemberSymbol(tostring(key)) + * except FstArgError: + */ + } + __pyx_L3_error:; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":782 + * try: + * return self._table.MemberSymbol(tostring(key)) + * except FstArgError: # <<<<<<<<<<<<<< + * return self._table.MemberIndex(key) + * + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 782, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_11 = __Pyx_PyErr_ExceptionMatches(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_11) { + __Pyx_AddTraceback("pywrapfst._SymbolTable.member", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3) < 0) __PYX_ERR(0, 782, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_t_3); + + /* "pywrapfst.pyx":783 + * return self._table.MemberSymbol(tostring(key)) + * except FstArgError: + * return self._table.MemberIndex(key) # <<<<<<<<<<<<<< + * + * def __contains__(self, key): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 783, __pyx_L5_except_error) + } + __pyx_t_12 = __Pyx_PyInt_As_int64_t(__pyx_v_key); if (unlikely((__pyx_t_12 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 783, __pyx_L5_except_error) + __pyx_r = __pyx_v_self->_table->Member(__pyx_t_12); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L6_except_return; + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "pywrapfst.pyx":780 + * Whether or not the key is present (as a string or a index) in the table. + * """ + * try: # <<<<<<<<<<<<<< + * return self._table.MemberSymbol(tostring(key)) + * except FstArgError: + */ + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + goto __pyx_L1_error; + __pyx_L7_try_return:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + goto __pyx_L0; + __pyx_L6_except_return:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + goto __pyx_L0; + } + + /* "pywrapfst.pyx":764 + * return self._table.LabeledCheckSum() + * + * cpdef bool member(self, key): # <<<<<<<<<<<<<< + * """ + * member(self, key) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_WriteUnraisable("pywrapfst._SymbolTable.member", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_17member(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ +static char __pyx_doc_9pywrapfst_12_SymbolTable_16member[] = "\n member(self, key)\n\n Given a symbol or index, returns whether it is found in the table.\n\n This method returns a boolean indicating whether the given symbol or index\n is present in the table. If one intends to perform subsequent lookup, it is\n better to simply call the find method, catching the KeyError.\n\n Args:\n key: Either a string or an index.\n\n Returns:\n Whether or not the key is present (as a string or a index) in the table.\n "; +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_17member(PyObject *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("member (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_16member(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self), ((PyObject *)__pyx_v_key)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_16member(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("member", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_9pywrapfst_12_SymbolTable_member(__pyx_v_self, __pyx_v_key, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 764, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._SymbolTable.member", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":785 + * return self._table.MemberIndex(key) + * + * def __contains__(self, key): # <<<<<<<<<<<<<< + * return self.member(key) + * + */ + +/* Python wrapper */ +static int __pyx_pw_9pywrapfst_12_SymbolTable_19__contains__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ +static int __pyx_pw_9pywrapfst_12_SymbolTable_19__contains__(PyObject *__pyx_v_self, PyObject *__pyx_v_key) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__contains__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_18__contains__(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self), ((PyObject *)__pyx_v_key)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pywrapfst_12_SymbolTable_18__contains__(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_key) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__contains__", 0); + + /* "pywrapfst.pyx":786 + * + * def __contains__(self, key): + * return self.member(key) # <<<<<<<<<<<<<< + * + * cpdef string name(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "member"); + __PYX_ERR(0, 786, __pyx_L1_error) + } + __pyx_r = ((struct __pyx_vtabstruct_9pywrapfst__SymbolTable *)__pyx_v_self->__pyx_vtab)->member(__pyx_v_self, __pyx_v_key, 0); + goto __pyx_L0; + + /* "pywrapfst.pyx":785 + * return self._table.MemberIndex(key) + * + * def __contains__(self, key): # <<<<<<<<<<<<<< + * return self.member(key) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._SymbolTable.__contains__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":788 + * return self.member(key) + * + * cpdef string name(self): # <<<<<<<<<<<<<< + * """ + * name(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_21name(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static std::string __pyx_f_9pywrapfst_12_SymbolTable_name(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch) { + std::string __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + std::string __pyx_t_5; + __Pyx_RefNannySetupContext("name", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 788, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_21name)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 788, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 788, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 788, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":794 + * Returns the symbol table's name. + * """ + * return self._table.Name() # <<<<<<<<<<<<<< + * + * cpdef size_t num_symbols(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 794, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_table->Name(); + goto __pyx_L0; + + /* "pywrapfst.pyx":788 + * return self.member(key) + * + * cpdef string name(self): # <<<<<<<<<<<<<< + * """ + * name(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst._SymbolTable.name", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_21name(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_12_SymbolTable_20name[] = "\n name(self)\n\n Returns the symbol table's name.\n "; +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_21name(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("name (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_20name(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_20name(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("name", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_12_SymbolTable_name(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 788, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._SymbolTable.name", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":796 + * return self._table.Name() + * + * cpdef size_t num_symbols(self): # <<<<<<<<<<<<<< + * """ + * num_symbols(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_23num_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static size_t __pyx_f_9pywrapfst_12_SymbolTable_num_symbols(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch) { + size_t __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + __Pyx_RefNannySetupContext("num_symbols", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_num_symbols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 796, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_23num_symbols)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 796, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 796, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_5 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 796, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":802 + * Returns the number of symbols in the symbol table. + * """ + * return self._table.NumSymbols() # <<<<<<<<<<<<<< + * + * cpdef void write(self, filename) except *: + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 802, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_table->NumSymbols(); + goto __pyx_L0; + + /* "pywrapfst.pyx":796 + * return self._table.Name() + * + * cpdef size_t num_symbols(self): # <<<<<<<<<<<<<< + * """ + * num_symbols(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst._SymbolTable.num_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_23num_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_12_SymbolTable_22num_symbols[] = "\n num_symbols(self)\n\n Returns the number of symbols in the symbol table.\n "; +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_23num_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("num_symbols (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_22num_symbols(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_22num_symbols(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("num_symbols", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_f_9pywrapfst_12_SymbolTable_num_symbols(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 796, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._SymbolTable.num_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":804 + * return self._table.NumSymbols() + * + * cpdef void write(self, filename) except *: # <<<<<<<<<<<<<< + * """ + * write(self, filename) + */ + +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_25write(PyObject *__pyx_v_self, PyObject *__pyx_v_filename); /*proto*/ +static void __pyx_f_9pywrapfst_12_SymbolTable_write(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_filename, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + std::string __pyx_t_6; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("write", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_write); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 804, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_25write)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_filename); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 804, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 804, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 804, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 804, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_filename); + __Pyx_GIVEREF(__pyx_v_filename); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_filename); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 804, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":818 + * FstIOError: Write failed. + * """ + * if not self._table.Write(tostring(filename)): # <<<<<<<<<<<<<< + * raise FstIOError("Write failed: {!r}".format(filename)) + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 818, __pyx_L1_error) + } + __pyx_t_6 = __pyx_f_9pywrapfst_tostring(__pyx_v_filename, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 818, __pyx_L1_error) + __pyx_t_7 = ((!(__pyx_v_self->_table->Write(__pyx_t_6) != 0)) != 0); + if (__pyx_t_7) { + + /* "pywrapfst.pyx":819 + * """ + * if not self._table.Write(tostring(filename)): + * raise FstIOError("Write failed: {!r}".format(filename)) # <<<<<<<<<<<<<< + * + * cpdef void write_text(self, filename) except *: + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIOError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 819, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Write_failed_r, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 819, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_4) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_filename); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 819, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 819, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 819, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 819, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_filename); + __Pyx_GIVEREF(__pyx_v_filename); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_filename); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 819, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_5) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 819, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 819, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 819, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 819, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 819, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 819, __pyx_L1_error) + + /* "pywrapfst.pyx":818 + * FstIOError: Write failed. + * """ + * if not self._table.Write(tostring(filename)): # <<<<<<<<<<<<<< + * raise FstIOError("Write failed: {!r}".format(filename)) + * + */ + } + + /* "pywrapfst.pyx":804 + * return self._table.NumSymbols() + * + * cpdef void write(self, filename) except *: # <<<<<<<<<<<<<< + * """ + * write(self, filename) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pywrapfst._SymbolTable.write", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_25write(PyObject *__pyx_v_self, PyObject *__pyx_v_filename); /*proto*/ +static char __pyx_doc_9pywrapfst_12_SymbolTable_24write[] = "\n write(self, filename)\n\n Serializes symbol table to a file.\n\n This methods writes the SymbolTable to a file in binary format.\n\n Args:\n filename: The string location of the output file.\n\n Raises:\n FstIOError: Write failed.\n "; +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_25write(PyObject *__pyx_v_self, PyObject *__pyx_v_filename) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("write (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_24write(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self), ((PyObject *)__pyx_v_filename)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_24write(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_filename) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("write", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_f_9pywrapfst_12_SymbolTable_write(__pyx_v_self, __pyx_v_filename, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 804, __pyx_L1_error) + __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 804, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._SymbolTable.write", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":821 + * raise FstIOError("Write failed: {!r}".format(filename)) + * + * cpdef void write_text(self, filename) except *: # <<<<<<<<<<<<<< + * """ + * write_text(self, filename) + */ + +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_27write_text(PyObject *__pyx_v_self, PyObject *__pyx_v_filename); /*proto*/ +static void __pyx_f_9pywrapfst_12_SymbolTable_write_text(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_filename, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + std::string __pyx_t_6; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("write_text", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_write_text); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 821, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_27write_text)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_filename); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 821, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 821, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 821, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 821, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_filename); + __Pyx_GIVEREF(__pyx_v_filename); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_filename); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 821, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":835 + * FstIOError: Write failed. + * """ + * if not self._table.WriteText(tostring(filename)): # <<<<<<<<<<<<<< + * raise FstIOError("Write failed: {!r}".format(filename)) + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 835, __pyx_L1_error) + } + __pyx_t_6 = __pyx_f_9pywrapfst_tostring(__pyx_v_filename, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 835, __pyx_L1_error) + __pyx_t_7 = ((!(__pyx_v_self->_table->WriteText(__pyx_t_6) != 0)) != 0); + if (__pyx_t_7) { + + /* "pywrapfst.pyx":836 + * """ + * if not self._table.WriteText(tostring(filename)): + * raise FstIOError("Write failed: {!r}".format(filename)) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIOError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 836, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Write_failed_r, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 836, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_4) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_filename); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 836, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 836, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 836, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 836, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_filename); + __Pyx_GIVEREF(__pyx_v_filename); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_filename); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 836, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_5) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 836, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 836, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 836, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 836, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 836, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 836, __pyx_L1_error) + + /* "pywrapfst.pyx":835 + * FstIOError: Write failed. + * """ + * if not self._table.WriteText(tostring(filename)): # <<<<<<<<<<<<<< + * raise FstIOError("Write failed: {!r}".format(filename)) + * + */ + } + + /* "pywrapfst.pyx":821 + * raise FstIOError("Write failed: {!r}".format(filename)) + * + * cpdef void write_text(self, filename) except *: # <<<<<<<<<<<<<< + * """ + * write_text(self, filename) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pywrapfst._SymbolTable.write_text", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_27write_text(PyObject *__pyx_v_self, PyObject *__pyx_v_filename); /*proto*/ +static char __pyx_doc_9pywrapfst_12_SymbolTable_26write_text[] = "\n write_text(self, filename)\n\n Writes symbol table to text file.\n\n This method writes the SymbolTable to a file in human-readable format.\n\n Args:\n filename: The string location of the output file.\n\n Raises:\n FstIOError: Write failed.\n "; +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_27write_text(PyObject *__pyx_v_self, PyObject *__pyx_v_filename) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("write_text (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_26write_text(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self), ((PyObject *)__pyx_v_filename)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_26write_text(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_filename) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("write_text", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_f_9pywrapfst_12_SymbolTable_write_text(__pyx_v_self, __pyx_v_filename, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 821, __pyx_L1_error) + __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 821, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._SymbolTable.write_text", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_29__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_29__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_28__reduce_cython__(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_28__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._table cannot be converted to a Python object for pickling") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._SymbolTable.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._table cannot be converted to a Python object for pickling") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_31__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_31__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_30__setstate_cython__(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_30__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError("self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._table cannot be converted to a Python object for pickling") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._SymbolTable.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":854 + * # Doing so will allow undefined behavior. + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "".format(self.name(), + * id(self)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_24_EncodeMapperSymbolTable_1__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_24_EncodeMapperSymbolTable_1__repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_24_EncodeMapperSymbolTable___repr__(((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_24_EncodeMapperSymbolTable___repr__(struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "pywrapfst.pyx":855 + * + * def __repr__(self): + * return "".format(self.name(), # <<<<<<<<<<<<<< + * id(self)) + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_const_EncodeMapper_SymbolTable, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 855, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "name"); + __PYX_ERR(0, 855, __pyx_L1_error) + } + __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst__EncodeMapperSymbolTable *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.name(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self), 0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 855, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "pywrapfst.pyx":856 + * def __repr__(self): + * return "".format(self.name(), + * id(self)) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 856, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_self)); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 856, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 855, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 855, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 855, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_5); + __pyx_t_3 = 0; + __pyx_t_5 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 855, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":854 + * # Doing so will allow undefined behavior. + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "".format(self.name(), + * id(self)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pywrapfst._EncodeMapperSymbolTable.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._encoder,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_24_EncodeMapperSymbolTable_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_24_EncodeMapperSymbolTable_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_24_EncodeMapperSymbolTable_2__reduce_cython__(((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_24_EncodeMapperSymbolTable_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._encoder,self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._encoder,self._table cannot be converted to a Python object for pickling") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._encoder,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._EncodeMapperSymbolTable.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._encoder,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._encoder,self._table cannot be converted to a Python object for pickling") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_24_EncodeMapperSymbolTable_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_24_EncodeMapperSymbolTable_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_24_EncodeMapperSymbolTable_4__setstate_cython__(((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_24_EncodeMapperSymbolTable_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError("self._encoder,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._encoder,self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._encoder,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._encoder,self._table cannot be converted to a Python object for pickling") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._EncodeMapperSymbolTable.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":873 + * # Doing so will allow undefined behavior. + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "".format(self.name(), + * id(self)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_15_FstSymbolTable_1__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_15_FstSymbolTable_1__repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_15_FstSymbolTable___repr__(((struct __pyx_obj_9pywrapfst__FstSymbolTable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_15_FstSymbolTable___repr__(struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "pywrapfst.pyx":874 + * + * def __repr__(self): + * return "".format(self.name(), # <<<<<<<<<<<<<< + * id(self)) + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_const_Fst_SymbolTable_r_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 874, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "name"); + __PYX_ERR(0, 874, __pyx_L1_error) + } + __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst__FstSymbolTable *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.name(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self), 0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 874, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "pywrapfst.pyx":875 + * def __repr__(self): + * return "".format(self.name(), + * id(self)) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 875, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_self)); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 875, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 874, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 874, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 874, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_5); + __pyx_t_3 = 0; + __pyx_t_5 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 874, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":873 + * # Doing so will allow undefined behavior. + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "".format(self.name(), + * id(self)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pywrapfst._FstSymbolTable.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._fst,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_15_FstSymbolTable_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_15_FstSymbolTable_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_15_FstSymbolTable_2__reduce_cython__(((struct __pyx_obj_9pywrapfst__FstSymbolTable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_15_FstSymbolTable_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._fst,self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._fst,self._table cannot be converted to a Python object for pickling") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._fst,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._FstSymbolTable.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._fst,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._fst,self._table cannot be converted to a Python object for pickling") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_15_FstSymbolTable_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_15_FstSymbolTable_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_15_FstSymbolTable_4__setstate_cython__(((struct __pyx_obj_9pywrapfst__FstSymbolTable *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_15_FstSymbolTable_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError("self._fst,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._fst,self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._fst,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._fst,self._table cannot be converted to a Python object for pickling") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._FstSymbolTable.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":889 + * """ + * + * cpdef int64 add_symbol(self, symbol, int64 key=kNoSymbol): # <<<<<<<<<<<<<< + * """ + * add_symbol(self, symbol, key=NO_SYMBOL) + */ + +static PyObject *__pyx_pw_9pywrapfst_19_MutableSymbolTable_1add_symbol(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_19_MutableSymbolTable_add_symbol(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, PyObject *__pyx_v_symbol, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_19_MutableSymbolTable_add_symbol *__pyx_optional_args) { + __pyx_t_10basictypes_int64 __pyx_v_key = __pyx_k__13; + std::string __pyx_v_symbol_string; + __pyx_t_10basictypes_int64 __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + __pyx_t_10basictypes_int64 __pyx_t_8; + std::string __pyx_t_9; + int __pyx_t_10; + __Pyx_RefNannySetupContext("add_symbol", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_key = __pyx_optional_args->key; + } + } + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_symbol); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 889, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_19_MutableSymbolTable_1add_symbol)) { + __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_v_key); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 889, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_symbol, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 889, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_symbol, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 889, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 889, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_INCREF(__pyx_v_symbol); + __Pyx_GIVEREF(__pyx_v_symbol); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_v_symbol); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 889, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_8 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_8 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 889, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_8; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":906 + * The integer key of the new symbol. + * """ + * cdef string symbol_string = tostring(symbol) # <<<<<<<<<<<<<< + * if key != kNoSymbol: + * return self._table.AddSymbol(symbol_string, key) + */ + __pyx_t_9 = __pyx_f_9pywrapfst_tostring(__pyx_v_symbol, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 906, __pyx_L1_error) + __pyx_v_symbol_string = __pyx_t_9; + + /* "pywrapfst.pyx":907 + * """ + * cdef string symbol_string = tostring(symbol) + * if key != kNoSymbol: # <<<<<<<<<<<<<< + * return self._table.AddSymbol(symbol_string, key) + * else: + */ + __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_v_key); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 907, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_kNoSymbol); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 907, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 907, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 907, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_10) { + + /* "pywrapfst.pyx":908 + * cdef string symbol_string = tostring(symbol) + * if key != kNoSymbol: + * return self._table.AddSymbol(symbol_string, key) # <<<<<<<<<<<<<< + * else: + * return self._table.AddSymbol(symbol_string) + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 908, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->__pyx_base._table->AddSymbol(__pyx_v_symbol_string, __pyx_v_key); + goto __pyx_L0; + + /* "pywrapfst.pyx":907 + * """ + * cdef string symbol_string = tostring(symbol) + * if key != kNoSymbol: # <<<<<<<<<<<<<< + * return self._table.AddSymbol(symbol_string, key) + * else: + */ + } + + /* "pywrapfst.pyx":910 + * return self._table.AddSymbol(symbol_string, key) + * else: + * return self._table.AddSymbol(symbol_string) # <<<<<<<<<<<<<< + * + * cpdef void add_table(self, _SymbolTable syms): + */ + /*else*/ { + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 910, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->__pyx_base._table->AddSymbol(__pyx_v_symbol_string); + goto __pyx_L0; + } + + /* "pywrapfst.pyx":889 + * """ + * + * cpdef int64 add_symbol(self, symbol, int64 key=kNoSymbol): # <<<<<<<<<<<<<< + * """ + * add_symbol(self, symbol, key=NO_SYMBOL) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_WriteUnraisable("pywrapfst._MutableSymbolTable.add_symbol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_19_MutableSymbolTable_1add_symbol(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_19_MutableSymbolTable_add_symbol[] = "\n add_symbol(self, symbol, key=NO_SYMBOL)\n\n Adds a symbol to the table and returns the index.\n\n This method adds a symbol to the table. The caller can optionally\n specify a non-negative integer index for the key.\n\n Args:\n symbol: A symbol string.\n key: An index for the symbol; if not specified, the next index will be\n used.\n\n Returns:\n The integer key of the new symbol.\n "; +static PyObject *__pyx_pw_9pywrapfst_19_MutableSymbolTable_1add_symbol(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_symbol = 0; + __pyx_t_10basictypes_int64 __pyx_v_key; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("add_symbol (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_symbol,&__pyx_n_s_key,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_symbol)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_key); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "add_symbol") < 0)) __PYX_ERR(0, 889, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_symbol = values[0]; + if (values[1]) { + __pyx_v_key = __Pyx_PyInt_As_int64_t(values[1]); if (unlikely((__pyx_v_key == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 889, __pyx_L3_error) + } else { + __pyx_v_key = __pyx_k__13; + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("add_symbol", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 889, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._MutableSymbolTable.add_symbol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_19_MutableSymbolTable_add_symbol(((struct __pyx_obj_9pywrapfst__MutableSymbolTable *)__pyx_v_self), __pyx_v_symbol, __pyx_v_key); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_19_MutableSymbolTable_add_symbol(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, PyObject *__pyx_v_symbol, __pyx_t_10basictypes_int64 __pyx_v_key) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __pyx_t_10basictypes_int64 __pyx_t_1; + struct __pyx_opt_args_9pywrapfst_19_MutableSymbolTable_add_symbol __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("add_symbol", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 1; + __pyx_t_2.key = __pyx_v_key; + __pyx_t_1 = __pyx_vtabptr_9pywrapfst__MutableSymbolTable->add_symbol(__pyx_v_self, __pyx_v_symbol, 1, &__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 889, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pywrapfst._MutableSymbolTable.add_symbol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":912 + * return self._table.AddSymbol(symbol_string) + * + * cpdef void add_table(self, _SymbolTable syms): # <<<<<<<<<<<<<< + * """ + * add_table(self, syms) + */ + +static PyObject *__pyx_pw_9pywrapfst_19_MutableSymbolTable_3add_table(PyObject *__pyx_v_self, PyObject *__pyx_v_syms); /*proto*/ +static void __pyx_f_9pywrapfst_19_MutableSymbolTable_add_table(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("add_table", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_table); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 912, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_19_MutableSymbolTable_3add_table)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_syms)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 912, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, ((PyObject *)__pyx_v_syms)}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 912, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, ((PyObject *)__pyx_v_syms)}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 912, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 912, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(((PyObject *)__pyx_v_syms)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_syms)); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, ((PyObject *)__pyx_v_syms)); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 912, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":924 + * syms: A SymbolTable to be merged with the current table. + * """ + * self._table.AddTable(deref(syms._table)) # <<<<<<<<<<<<<< + * + * cpdef void set_name(self, new_name) except *: + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 924, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_syms) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 924, __pyx_L1_error) + } + __pyx_v_self->__pyx_base._table->AddTable((*__pyx_v_syms->_table)); + + /* "pywrapfst.pyx":912 + * return self._table.AddSymbol(symbol_string) + * + * cpdef void add_table(self, _SymbolTable syms): # <<<<<<<<<<<<<< + * """ + * add_table(self, syms) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_WriteUnraisable("pywrapfst._MutableSymbolTable.add_table", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_19_MutableSymbolTable_3add_table(PyObject *__pyx_v_self, PyObject *__pyx_v_syms); /*proto*/ +static char __pyx_doc_9pywrapfst_19_MutableSymbolTable_2add_table[] = "\n add_table(self, syms)\n\n Adds another SymbolTable to this table.\n\n This method merges another symbol table into the current table. All key\n values will be offset by the current available key.\n\n Args:\n syms: A SymbolTable to be merged with the current table.\n "; +static PyObject *__pyx_pw_9pywrapfst_19_MutableSymbolTable_3add_table(PyObject *__pyx_v_self, PyObject *__pyx_v_syms) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("add_table (wrapper)", 0); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_syms), __pyx_ptype_9pywrapfst__SymbolTable, 1, "syms", 0))) __PYX_ERR(0, 912, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_19_MutableSymbolTable_2add_table(((struct __pyx_obj_9pywrapfst__MutableSymbolTable *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_syms)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_19_MutableSymbolTable_2add_table(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("add_table", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_19_MutableSymbolTable_add_table(__pyx_v_self, __pyx_v_syms, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 912, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._MutableSymbolTable.add_table", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":926 + * self._table.AddTable(deref(syms._table)) + * + * cpdef void set_name(self, new_name) except *: # <<<<<<<<<<<<<< + * self._table.SetName(tostring(new_name)) + * + */ + +static PyObject *__pyx_pw_9pywrapfst_19_MutableSymbolTable_5set_name(PyObject *__pyx_v_self, PyObject *__pyx_v_new_name); /*proto*/ +static void __pyx_f_9pywrapfst_19_MutableSymbolTable_set_name(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, PyObject *__pyx_v_new_name, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + std::string __pyx_t_6; + __Pyx_RefNannySetupContext("set_name", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 926, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_19_MutableSymbolTable_5set_name)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_new_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 926, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_new_name}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 926, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_new_name}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 926, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 926, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_new_name); + __Pyx_GIVEREF(__pyx_v_new_name); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_new_name); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 926, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":927 + * + * cpdef void set_name(self, new_name) except *: + * self._table.SetName(tostring(new_name)) # <<<<<<<<<<<<<< + * + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 927, __pyx_L1_error) + } + __pyx_t_6 = __pyx_f_9pywrapfst_tostring(__pyx_v_new_name, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 927, __pyx_L1_error) + __pyx_v_self->__pyx_base._table->SetName(__pyx_t_6); + + /* "pywrapfst.pyx":926 + * self._table.AddTable(deref(syms._table)) + * + * cpdef void set_name(self, new_name) except *: # <<<<<<<<<<<<<< + * self._table.SetName(tostring(new_name)) + * + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pywrapfst._MutableSymbolTable.set_name", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_19_MutableSymbolTable_5set_name(PyObject *__pyx_v_self, PyObject *__pyx_v_new_name); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_19_MutableSymbolTable_5set_name(PyObject *__pyx_v_self, PyObject *__pyx_v_new_name) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_name (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_19_MutableSymbolTable_4set_name(((struct __pyx_obj_9pywrapfst__MutableSymbolTable *)__pyx_v_self), ((PyObject *)__pyx_v_new_name)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_19_MutableSymbolTable_4set_name(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, PyObject *__pyx_v_new_name) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("set_name", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_f_9pywrapfst_19_MutableSymbolTable_set_name(__pyx_v_self, __pyx_v_new_name, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 926, __pyx_L1_error) + __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 926, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._MutableSymbolTable.set_name", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_19_MutableSymbolTable_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_19_MutableSymbolTable_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_19_MutableSymbolTable_6__reduce_cython__(((struct __pyx_obj_9pywrapfst__MutableSymbolTable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_19_MutableSymbolTable_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._table cannot be converted to a Python object for pickling") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._MutableSymbolTable.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._table cannot be converted to a Python object for pickling") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_19_MutableSymbolTable_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_19_MutableSymbolTable_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_19_MutableSymbolTable_8__setstate_cython__(((struct __pyx_obj_9pywrapfst__MutableSymbolTable *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_19_MutableSymbolTable_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError("self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._table cannot be converted to a Python object for pickling") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._MutableSymbolTable.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":937 + * """ + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "".format(self.name(), id(self)) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_22_MutableFstSymbolTable_1__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_22_MutableFstSymbolTable_1__repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_22_MutableFstSymbolTable___repr__(((struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_22_MutableFstSymbolTable___repr__(struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "pywrapfst.pyx":938 + * + * def __repr__(self): + * return "".format(self.name(), id(self)) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Fst_SymbolTable_r_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 938, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "name"); + __PYX_ERR(0, 938, __pyx_L1_error) + } + __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst__MutableFstSymbolTable *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.name(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self), 0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 938, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 938, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_self)); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 938, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 938, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 938, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 938, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_5); + __pyx_t_3 = 0; + __pyx_t_5 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 938, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":937 + * """ + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "".format(self.name(), id(self)) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pywrapfst._MutableFstSymbolTable.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._mfst,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_22_MutableFstSymbolTable_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_22_MutableFstSymbolTable_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_22_MutableFstSymbolTable_2__reduce_cython__(((struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_22_MutableFstSymbolTable_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._mfst,self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._mfst,self._table cannot be converted to a Python object for pickling") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._mfst,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._MutableFstSymbolTable.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._mfst,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._mfst,self._table cannot be converted to a Python object for pickling") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_22_MutableFstSymbolTable_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_22_MutableFstSymbolTable_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_22_MutableFstSymbolTable_4__setstate_cython__(((struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_22_MutableFstSymbolTable_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError("self._mfst,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._mfst,self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._mfst,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._mfst,self._table cannot be converted to a Python object for pickling") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._MutableFstSymbolTable.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":958 + * """ + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "".format(self.name(), id(self)) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_1__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_1__repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_11SymbolTable___repr__(((struct __pyx_obj_9pywrapfst_SymbolTable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11SymbolTable___repr__(struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "pywrapfst.pyx":959 + * + * def __repr__(self): + * return "".format(self.name(), id(self)) # <<<<<<<<<<<<<< + * + * def __init__(self, name=b""): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_SymbolTable_r_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 959, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "name"); + __PYX_ERR(0, 959, __pyx_L1_error) + } + __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst_SymbolTable *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.name(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self), 0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 959, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 959, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_self)); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 959, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 959, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 959, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 959, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_5); + __pyx_t_3 = 0; + __pyx_t_5 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 959, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":958 + * """ + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "".format(self.name(), id(self)) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pywrapfst.SymbolTable.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":961 + * return "".format(self.name(), id(self)) + * + * def __init__(self, name=b""): # <<<<<<<<<<<<<< + * self._table = new fst.SymbolTable(tostring(name)) + * self._smart_table.reset(self._table) + */ + +/* Python wrapper */ +static int __pyx_pw_9pywrapfst_11SymbolTable_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_9pywrapfst_11SymbolTable_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_name = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name_2,0}; + PyObject* values[1] = {0}; + values[0] = ((PyObject *)__pyx_kp_b_unspecified); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_name_2); + if (value) { values[0] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 961, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_name = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 961, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.SymbolTable.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_11SymbolTable_2__init__(((struct __pyx_obj_9pywrapfst_SymbolTable *)__pyx_v_self), __pyx_v_name); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pywrapfst_11SymbolTable_2__init__(struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_self, PyObject *__pyx_v_name) { + int __pyx_r; + __Pyx_RefNannyDeclarations + std::string __pyx_t_1; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "pywrapfst.pyx":962 + * + * def __init__(self, name=b""): + * self._table = new fst.SymbolTable(tostring(name)) # <<<<<<<<<<<<<< + * self._smart_table.reset(self._table) + * + */ + __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_name, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 962, __pyx_L1_error) + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 962, __pyx_L1_error) + } + __pyx_v_self->__pyx_base.__pyx_base._table = new fst::SymbolTable(__pyx_t_1); + + /* "pywrapfst.pyx":963 + * def __init__(self, name=b""): + * self._table = new fst.SymbolTable(tostring(name)) + * self._smart_table.reset(self._table) # <<<<<<<<<<<<<< + * + * @classmethod + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_smart_table"); + __PYX_ERR(0, 963, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 963, __pyx_L1_error) + } + __pyx_v_self->_smart_table.reset(__pyx_v_self->__pyx_base.__pyx_base._table); + + /* "pywrapfst.pyx":961 + * return "".format(self.name(), id(self)) + * + * def __init__(self, name=b""): # <<<<<<<<<<<<<< + * self._table = new fst.SymbolTable(tostring(name)) + * self._smart_table.reset(self._table) + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst.SymbolTable.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":966 + * + * @classmethod + * def read(cls, filename): # <<<<<<<<<<<<<< + * """ + * SymbolTable.read(filename) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_5read(PyObject *__pyx_v_cls, PyObject *__pyx_v_filename); /*proto*/ +static char __pyx_doc_9pywrapfst_11SymbolTable_4read[] = "\n SymbolTable.read(filename)\n\n Reads symbol table from binary file.\n\n This class method creates a new SymbolTable from a symbol table binary file.\n\n Args:\n filename: The string location of the input binary file.\n\n Returns:\n A new SymbolTable instance.\n\n See also: `SymbolTable.read_fst`, `SymbolTable.read_text`.\n "; +static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_5read(PyObject *__pyx_v_cls, PyObject *__pyx_v_filename) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("read (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_11SymbolTable_4read(((PyTypeObject*)__pyx_v_cls), ((PyObject *)__pyx_v_filename)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11SymbolTable_4read(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_filename) { + fst::SymbolTable *__pyx_v_tsyms; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + std::string __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("read", 0); + + /* "pywrapfst.pyx":982 + * See also: `SymbolTable.read_fst`, `SymbolTable.read_text`. + * """ + * cdef fst.SymbolTable *tsyms = fst.SymbolTable.Read(tostring(filename)) # <<<<<<<<<<<<<< + * if tsyms == NULL: + * raise FstIOError("Read failed: {!r}".format(filename)) + */ + __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_filename, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 982, __pyx_L1_error) + __pyx_v_tsyms = fst::SymbolTable::Read(__pyx_t_1); + + /* "pywrapfst.pyx":983 + * """ + * cdef fst.SymbolTable *tsyms = fst.SymbolTable.Read(tostring(filename)) + * if tsyms == NULL: # <<<<<<<<<<<<<< + * raise FstIOError("Read failed: {!r}".format(filename)) + * return _init_SymbolTable(tsyms) + */ + __pyx_t_2 = ((__pyx_v_tsyms == NULL) != 0); + if (__pyx_t_2) { + + /* "pywrapfst.pyx":984 + * cdef fst.SymbolTable *tsyms = fst.SymbolTable.Read(tostring(filename)) + * if tsyms == NULL: + * raise FstIOError("Read failed: {!r}".format(filename)) # <<<<<<<<<<<<<< + * return _init_SymbolTable(tsyms) + * + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIOError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 984, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Read_failed_r, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 984, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + if (!__pyx_t_7) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_filename); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 984, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_filename}; + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 984, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_filename}; + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 984, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 984, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_INCREF(__pyx_v_filename); + __Pyx_GIVEREF(__pyx_v_filename); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_filename); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 984, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_6) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 984, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 984, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 984, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 984, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 984, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 984, __pyx_L1_error) + + /* "pywrapfst.pyx":983 + * """ + * cdef fst.SymbolTable *tsyms = fst.SymbolTable.Read(tostring(filename)) + * if tsyms == NULL: # <<<<<<<<<<<<<< + * raise FstIOError("Read failed: {!r}".format(filename)) + * return _init_SymbolTable(tsyms) + */ + } + + /* "pywrapfst.pyx":985 + * if tsyms == NULL: + * raise FstIOError("Read failed: {!r}".format(filename)) + * return _init_SymbolTable(tsyms) # <<<<<<<<<<<<<< + * + * @classmethod + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_SymbolTable(__pyx_v_tsyms)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 985, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":966 + * + * @classmethod + * def read(cls, filename): # <<<<<<<<<<<<<< + * """ + * SymbolTable.read(filename) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pywrapfst.SymbolTable.read", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":988 + * + * @classmethod + * def read_text(cls, filename, bool allow_negative_labels=False): # <<<<<<<<<<<<<< + * """ + * SymbolTable.read_text(filename) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_7read_text(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_11SymbolTable_6read_text[] = "\n SymbolTable.read_text(filename)\n\n Reads symbol table from text file.\n\n This class method creates a new SymbolTable from a symbol table text file.\n\n Args:\n filename: The string location of the input text file.\n allow_negative_labels: Should negative labels be allowed? (Not\n recommended; may cause conflicts).\n\n Returns:\n A new SymbolTable instance.\n\n See also: `SymbolTable.read`, `SymbolTable.read_fst`.\n "; +static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_7read_text(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_filename = 0; + bool __pyx_v_allow_negative_labels; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("read_text (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_allow_negative_labels,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_filename)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_allow_negative_labels); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "read_text") < 0)) __PYX_ERR(0, 988, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_filename = values[0]; + if (values[1]) { + __pyx_v_allow_negative_labels = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_allow_negative_labels == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 988, __pyx_L3_error) + } else { + __pyx_v_allow_negative_labels = ((bool)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("read_text", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 988, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.SymbolTable.read_text", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_11SymbolTable_6read_text(((PyTypeObject*)__pyx_v_cls), __pyx_v_filename, __pyx_v_allow_negative_labels); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11SymbolTable_6read_text(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_filename, bool __pyx_v_allow_negative_labels) { + std::unique_ptr __pyx_v_opts; + fst::SymbolTable *__pyx_v_tsyms; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + std::string __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("read_text", 0); + + /* "pywrapfst.pyx":1007 + * """ + * cdef unique_ptr[fst.SymbolTableTextOptions] opts + * opts.reset(new fst.SymbolTableTextOptions(allow_negative_labels)) # <<<<<<<<<<<<<< + * cdef fst.SymbolTable *tsyms = fst.SymbolTable.ReadText(tostring(filename), + * deref(opts)) + */ + __pyx_v_opts.reset(new fst::SymbolTableTextOptions(__pyx_v_allow_negative_labels)); + + /* "pywrapfst.pyx":1008 + * cdef unique_ptr[fst.SymbolTableTextOptions] opts + * opts.reset(new fst.SymbolTableTextOptions(allow_negative_labels)) + * cdef fst.SymbolTable *tsyms = fst.SymbolTable.ReadText(tostring(filename), # <<<<<<<<<<<<<< + * deref(opts)) + * if tsyms == NULL: + */ + __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_filename, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1008, __pyx_L1_error) + + /* "pywrapfst.pyx":1009 + * opts.reset(new fst.SymbolTableTextOptions(allow_negative_labels)) + * cdef fst.SymbolTable *tsyms = fst.SymbolTable.ReadText(tostring(filename), + * deref(opts)) # <<<<<<<<<<<<<< + * if tsyms == NULL: + * raise FstIOError("Read failed: {!r}".format(filename)) + */ + __pyx_v_tsyms = fst::SymbolTable::ReadText(__pyx_t_1, (*__pyx_v_opts)); + + /* "pywrapfst.pyx":1010 + * cdef fst.SymbolTable *tsyms = fst.SymbolTable.ReadText(tostring(filename), + * deref(opts)) + * if tsyms == NULL: # <<<<<<<<<<<<<< + * raise FstIOError("Read failed: {!r}".format(filename)) + * return _init_SymbolTable(tsyms) + */ + __pyx_t_2 = ((__pyx_v_tsyms == NULL) != 0); + if (__pyx_t_2) { + + /* "pywrapfst.pyx":1011 + * deref(opts)) + * if tsyms == NULL: + * raise FstIOError("Read failed: {!r}".format(filename)) # <<<<<<<<<<<<<< + * return _init_SymbolTable(tsyms) + * + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIOError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1011, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Read_failed_r, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1011, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + if (!__pyx_t_7) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_filename); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1011, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_filename}; + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1011, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_filename}; + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1011, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1011, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_INCREF(__pyx_v_filename); + __Pyx_GIVEREF(__pyx_v_filename); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_filename); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1011, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_6) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1011, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1011, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1011, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1011, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1011, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 1011, __pyx_L1_error) + + /* "pywrapfst.pyx":1010 + * cdef fst.SymbolTable *tsyms = fst.SymbolTable.ReadText(tostring(filename), + * deref(opts)) + * if tsyms == NULL: # <<<<<<<<<<<<<< + * raise FstIOError("Read failed: {!r}".format(filename)) + * return _init_SymbolTable(tsyms) + */ + } + + /* "pywrapfst.pyx":1012 + * if tsyms == NULL: + * raise FstIOError("Read failed: {!r}".format(filename)) + * return _init_SymbolTable(tsyms) # <<<<<<<<<<<<<< + * + * @classmethod + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_SymbolTable(__pyx_v_tsyms)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1012, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":988 + * + * @classmethod + * def read_text(cls, filename, bool allow_negative_labels=False): # <<<<<<<<<<<<<< + * """ + * SymbolTable.read_text(filename) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pywrapfst.SymbolTable.read_text", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1015 + * + * @classmethod + * def read_fst(cls, filename, bool input_table): # <<<<<<<<<<<<<< + * """ + * SymbolTable.read_fst(filename, input_table) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_9read_fst(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_11SymbolTable_8read_fst[] = "\n SymbolTable.read_fst(filename, input_table)\n\n Reads symbol table from an FST file without loading the corresponding FST.\n\n This class method creates a new SymbolTable by reading either the input or\n output symbol table from an FST file, without loading the corresponding FST.\n\n Args:\n filename: The string location of the input FST file.\n input_table: Should the input table be read (True) or the output table\n (False)?\n\n Returns:\n A new SymbolTable instance, or None if none can be read.\n\n Raises:\n FstIOError: Read failed.\n\n See also: `SymbolTable.read`, `SymbolTable.read_text`.\n "; +static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_9read_fst(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_filename = 0; + bool __pyx_v_input_table; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("read_fst (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_input_table,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_filename)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_input_table)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("read_fst", 1, 2, 2, 1); __PYX_ERR(0, 1015, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "read_fst") < 0)) __PYX_ERR(0, 1015, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_filename = values[0]; + __pyx_v_input_table = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_input_table == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1015, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("read_fst", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1015, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.SymbolTable.read_fst", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_11SymbolTable_8read_fst(((PyTypeObject*)__pyx_v_cls), __pyx_v_filename, __pyx_v_input_table); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11SymbolTable_8read_fst(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_filename, bool __pyx_v_input_table) { + fst::SymbolTable *__pyx_v_tsyms; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + std::string __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("read_fst", 0); + + /* "pywrapfst.pyx":1037 + * See also: `SymbolTable.read`, `SymbolTable.read_text`. + * """ + * cdef fst.SymbolTable *tsyms = fst.FstReadSymbols(filename, input_table) # <<<<<<<<<<<<<< + * if tsyms == NULL: + * raise FstIOError("Read failed: {!r}".format(filename)) + */ + __pyx_t_1 = __pyx_convert_string_from_py_std__in_string(__pyx_v_filename); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1037, __pyx_L1_error) + __pyx_v_tsyms = fst::FstReadSymbols(__pyx_t_1, __pyx_v_input_table); + + /* "pywrapfst.pyx":1038 + * """ + * cdef fst.SymbolTable *tsyms = fst.FstReadSymbols(filename, input_table) + * if tsyms == NULL: # <<<<<<<<<<<<<< + * raise FstIOError("Read failed: {!r}".format(filename)) + * return _init_SymbolTable(tsyms) + */ + __pyx_t_2 = ((__pyx_v_tsyms == NULL) != 0); + if (__pyx_t_2) { + + /* "pywrapfst.pyx":1039 + * cdef fst.SymbolTable *tsyms = fst.FstReadSymbols(filename, input_table) + * if tsyms == NULL: + * raise FstIOError("Read failed: {!r}".format(filename)) # <<<<<<<<<<<<<< + * return _init_SymbolTable(tsyms) + * + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIOError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1039, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Read_failed_r, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1039, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + if (!__pyx_t_7) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_filename); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1039, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_filename}; + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1039, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_filename}; + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1039, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1039, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_INCREF(__pyx_v_filename); + __Pyx_GIVEREF(__pyx_v_filename); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_filename); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1039, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_6) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1039, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1039, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1039, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1039, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1039, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 1039, __pyx_L1_error) + + /* "pywrapfst.pyx":1038 + * """ + * cdef fst.SymbolTable *tsyms = fst.FstReadSymbols(filename, input_table) + * if tsyms == NULL: # <<<<<<<<<<<<<< + * raise FstIOError("Read failed: {!r}".format(filename)) + * return _init_SymbolTable(tsyms) + */ + } + + /* "pywrapfst.pyx":1040 + * if tsyms == NULL: + * raise FstIOError("Read failed: {!r}".format(filename)) + * return _init_SymbolTable(tsyms) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_SymbolTable(__pyx_v_tsyms)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1040, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":1015 + * + * @classmethod + * def read_fst(cls, filename, bool input_table): # <<<<<<<<<<<<<< + * """ + * SymbolTable.read_fst(filename, input_table) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pywrapfst.SymbolTable.read_fst", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._smart_table,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_11__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_11__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_11SymbolTable_10__reduce_cython__(((struct __pyx_obj_9pywrapfst_SymbolTable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11SymbolTable_10__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._smart_table,self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._smart_table,self._table cannot be converted to a Python object for pickling") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._smart_table,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.SymbolTable.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._smart_table,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._smart_table,self._table cannot be converted to a Python object for pickling") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_13__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_13__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_11SymbolTable_12__setstate_cython__(((struct __pyx_obj_9pywrapfst_SymbolTable *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11SymbolTable_12__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError("self._smart_table,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._smart_table,self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__19, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._smart_table,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._smart_table,self._table cannot be converted to a Python object for pickling") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.SymbolTable.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1043 + * + * + * cdef _EncodeMapperSymbolTable _init_EncodeMapperSymbolTable( # <<<<<<<<<<<<<< + * fst.SymbolTable *table, shared_ptr[fst.EncodeMapperClass] encoder): + * cdef _EncodeMapperSymbolTable result = ( + */ + +static struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_f_9pywrapfst__init_EncodeMapperSymbolTable(fst::SymbolTable *__pyx_v_table, std::shared_ptr __pyx_v_encoder) { + struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_v_result = 0; + struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_init_EncodeMapperSymbolTable", 0); + + /* "pywrapfst.pyx":1046 + * fst.SymbolTable *table, shared_ptr[fst.EncodeMapperClass] encoder): + * cdef _EncodeMapperSymbolTable result = ( + * _EncodeMapperSymbolTable.__new__(_EncodeMapperSymbolTable)) # <<<<<<<<<<<<<< + * result._table = table + * result._encoder = encoder + */ + __pyx_t_1 = __pyx_tp_new_9pywrapfst__EncodeMapperSymbolTable(((PyTypeObject *)__pyx_ptype_9pywrapfst__EncodeMapperSymbolTable), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1046, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst__EncodeMapperSymbolTable)))) __PYX_ERR(0, 1046, __pyx_L1_error) + __pyx_v_result = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pywrapfst.pyx":1047 + * cdef _EncodeMapperSymbolTable result = ( + * _EncodeMapperSymbolTable.__new__(_EncodeMapperSymbolTable)) + * result._table = table # <<<<<<<<<<<<<< + * result._encoder = encoder + * return result + */ + if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 1047, __pyx_L1_error) + } + __pyx_v_result->__pyx_base._table = __pyx_v_table; + + /* "pywrapfst.pyx":1048 + * _EncodeMapperSymbolTable.__new__(_EncodeMapperSymbolTable)) + * result._table = table + * result._encoder = encoder # <<<<<<<<<<<<<< + * return result + * + */ + if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_encoder"); + __PYX_ERR(0, 1048, __pyx_L1_error) + } + __pyx_v_result->_encoder = __pyx_v_encoder; + + /* "pywrapfst.pyx":1049 + * result._table = table + * result._encoder = encoder + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "pywrapfst.pyx":1043 + * + * + * cdef _EncodeMapperSymbolTable _init_EncodeMapperSymbolTable( # <<<<<<<<<<<<<< + * fst.SymbolTable *table, shared_ptr[fst.EncodeMapperClass] encoder): + * cdef _EncodeMapperSymbolTable result = ( + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._init_EncodeMapperSymbolTable", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1052 + * + * + * cdef _FstSymbolTable _init_FstSymbolTable(fst.SymbolTable *table, # <<<<<<<<<<<<<< + * shared_ptr[fst.FstClass] ifst): + * cdef _FstSymbolTable result = _FstSymbolTable.__new__(_FstSymbolTable) + */ + +static struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_f_9pywrapfst__init_FstSymbolTable(fst::SymbolTable *__pyx_v_table, std::shared_ptr __pyx_v_ifst) { + struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_v_result = 0; + struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_init_FstSymbolTable", 0); + + /* "pywrapfst.pyx":1054 + * cdef _FstSymbolTable _init_FstSymbolTable(fst.SymbolTable *table, + * shared_ptr[fst.FstClass] ifst): + * cdef _FstSymbolTable result = _FstSymbolTable.__new__(_FstSymbolTable) # <<<<<<<<<<<<<< + * result._table = table + * result._fst = ifst + */ + __pyx_t_1 = __pyx_tp_new_9pywrapfst__FstSymbolTable(((PyTypeObject *)__pyx_ptype_9pywrapfst__FstSymbolTable), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1054, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst__FstSymbolTable)))) __PYX_ERR(0, 1054, __pyx_L1_error) + __pyx_v_result = ((struct __pyx_obj_9pywrapfst__FstSymbolTable *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pywrapfst.pyx":1055 + * shared_ptr[fst.FstClass] ifst): + * cdef _FstSymbolTable result = _FstSymbolTable.__new__(_FstSymbolTable) + * result._table = table # <<<<<<<<<<<<<< + * result._fst = ifst + * return result + */ + if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 1055, __pyx_L1_error) + } + __pyx_v_result->__pyx_base._table = __pyx_v_table; + + /* "pywrapfst.pyx":1056 + * cdef _FstSymbolTable result = _FstSymbolTable.__new__(_FstSymbolTable) + * result._table = table + * result._fst = ifst # <<<<<<<<<<<<<< + * return result + * + */ + if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1056, __pyx_L1_error) + } + __pyx_v_result->_fst = __pyx_v_ifst; + + /* "pywrapfst.pyx":1057 + * result._table = table + * result._fst = ifst + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "pywrapfst.pyx":1052 + * + * + * cdef _FstSymbolTable _init_FstSymbolTable(fst.SymbolTable *table, # <<<<<<<<<<<<<< + * shared_ptr[fst.FstClass] ifst): + * cdef _FstSymbolTable result = _FstSymbolTable.__new__(_FstSymbolTable) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._init_FstSymbolTable", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1060 + * + * + * cdef _MutableFstSymbolTable _init_MutableFstSymbolTable(fst.SymbolTable *table, # <<<<<<<<<<<<<< + * shared_ptr[fst.MutableFstClass] ifst): + * cdef _MutableFstSymbolTable result = ( + */ + +static struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *__pyx_f_9pywrapfst__init_MutableFstSymbolTable(fst::SymbolTable *__pyx_v_table, std::shared_ptr __pyx_v_ifst) { + struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *__pyx_v_result = 0; + struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_init_MutableFstSymbolTable", 0); + + /* "pywrapfst.pyx":1063 + * shared_ptr[fst.MutableFstClass] ifst): + * cdef _MutableFstSymbolTable result = ( + * _MutableFstSymbolTable.__new__(_MutableFstSymbolTable)) # <<<<<<<<<<<<<< + * result._table = table + * result._mfst = ifst + */ + __pyx_t_1 = __pyx_tp_new_9pywrapfst__MutableFstSymbolTable(((PyTypeObject *)__pyx_ptype_9pywrapfst__MutableFstSymbolTable), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1063, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst__MutableFstSymbolTable)))) __PYX_ERR(0, 1063, __pyx_L1_error) + __pyx_v_result = ((struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pywrapfst.pyx":1064 + * cdef _MutableFstSymbolTable result = ( + * _MutableFstSymbolTable.__new__(_MutableFstSymbolTable)) + * result._table = table # <<<<<<<<<<<<<< + * result._mfst = ifst + * return result + */ + if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 1064, __pyx_L1_error) + } + __pyx_v_result->__pyx_base.__pyx_base._table = __pyx_v_table; + + /* "pywrapfst.pyx":1065 + * _MutableFstSymbolTable.__new__(_MutableFstSymbolTable)) + * result._table = table + * result._mfst = ifst # <<<<<<<<<<<<<< + * return result + * + */ + if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 1065, __pyx_L1_error) + } + __pyx_v_result->_mfst = __pyx_v_ifst; + + /* "pywrapfst.pyx":1066 + * result._table = table + * result._mfst = ifst + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "pywrapfst.pyx":1060 + * + * + * cdef _MutableFstSymbolTable _init_MutableFstSymbolTable(fst.SymbolTable *table, # <<<<<<<<<<<<<< + * shared_ptr[fst.MutableFstClass] ifst): + * cdef _MutableFstSymbolTable result = ( + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._init_MutableFstSymbolTable", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1069 + * + * + * cdef SymbolTable _init_SymbolTable(fst.SymbolTable *table): # <<<<<<<<<<<<<< + * cdef SymbolTable result = SymbolTable.__new__(SymbolTable) + * result._table = table + */ + +static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst__init_SymbolTable(fst::SymbolTable *__pyx_v_table) { + struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_result = 0; + struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_init_SymbolTable", 0); + + /* "pywrapfst.pyx":1070 + * + * cdef SymbolTable _init_SymbolTable(fst.SymbolTable *table): + * cdef SymbolTable result = SymbolTable.__new__(SymbolTable) # <<<<<<<<<<<<<< + * result._table = table + * return result + */ + __pyx_t_1 = __pyx_tp_new_9pywrapfst_SymbolTable(((PyTypeObject *)__pyx_ptype_9pywrapfst_SymbolTable), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1070, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_SymbolTable)))) __PYX_ERR(0, 1070, __pyx_L1_error) + __pyx_v_result = ((struct __pyx_obj_9pywrapfst_SymbolTable *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pywrapfst.pyx":1071 + * cdef SymbolTable _init_SymbolTable(fst.SymbolTable *table): + * cdef SymbolTable result = SymbolTable.__new__(SymbolTable) + * result._table = table # <<<<<<<<<<<<<< + * return result + * + */ + if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 1071, __pyx_L1_error) + } + __pyx_v_result->__pyx_base.__pyx_base._table = __pyx_v_table; + + /* "pywrapfst.pyx":1072 + * cdef SymbolTable result = SymbolTable.__new__(SymbolTable) + * result._table = table + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "pywrapfst.pyx":1069 + * + * + * cdef SymbolTable _init_SymbolTable(fst.SymbolTable *table): # <<<<<<<<<<<<<< + * cdef SymbolTable result = SymbolTable.__new__(SymbolTable) + * result._table = table + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._init_SymbolTable", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1078 + * + * + * cpdef SymbolTable compact_symbol_table(_SymbolTable syms): # <<<<<<<<<<<<<< + * """ + * compact_symbol_table(syms) + */ + +static PyObject *__pyx_pw_9pywrapfst_9compact_symbol_table(PyObject *__pyx_self, PyObject *__pyx_v_syms); /*proto*/ +static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst_compact_symbol_table(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms, CYTHON_UNUSED int __pyx_skip_dispatch) { + struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("compact_symbol_table", 0); + + /* "pywrapfst.pyx":1090 + * A new compacted SymbolTable. + * """ + * return _init_SymbolTable(fst.CompactSymbolTable(deref(syms._table))) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + if (unlikely(((PyObject *)__pyx_v_syms) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 1090, __pyx_L1_error) + } + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_SymbolTable(fst::CompactSymbolTable((*__pyx_v_syms->_table)))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1090, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = ((struct __pyx_obj_9pywrapfst_SymbolTable *)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":1078 + * + * + * cpdef SymbolTable compact_symbol_table(_SymbolTable syms): # <<<<<<<<<<<<<< + * """ + * compact_symbol_table(syms) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.compact_symbol_table", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_9compact_symbol_table(PyObject *__pyx_self, PyObject *__pyx_v_syms); /*proto*/ +static char __pyx_doc_9pywrapfst_8compact_symbol_table[] = "\n compact_symbol_table(syms)\n\n Constructively relabels a SymbolTable to make it a contiguous mapping.\n\n Args:\n syms: Input SymbolTable.\n\n Returns:\n A new compacted SymbolTable.\n "; +static PyObject *__pyx_pw_9pywrapfst_9compact_symbol_table(PyObject *__pyx_self, PyObject *__pyx_v_syms) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("compact_symbol_table (wrapper)", 0); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_syms), __pyx_ptype_9pywrapfst__SymbolTable, 1, "syms", 0))) __PYX_ERR(0, 1078, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_8compact_symbol_table(__pyx_self, ((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_syms)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_8compact_symbol_table(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("compact_symbol_table", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_compact_symbol_table(__pyx_v_syms, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1078, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.compact_symbol_table", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1093 + * + * + * cpdef SymbolTable merge_symbol_table(_SymbolTable lhs, _SymbolTable rhs): # <<<<<<<<<<<<<< + * """ + * merge_symbol_table(lhs, rhs) + */ + +static PyObject *__pyx_pw_9pywrapfst_11merge_symbol_table(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst_merge_symbol_table(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_lhs, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_rhs, CYTHON_UNUSED int __pyx_skip_dispatch) { + struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("merge_symbol_table", 0); + + /* "pywrapfst.pyx":1117 + * See also: `relabel_symbols`. + * """ + * return _init_SymbolTable(fst.MergeSymbolTable(deref(lhs._table), # <<<<<<<<<<<<<< + * deref(rhs._table), NULL)) + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + if (unlikely(((PyObject *)__pyx_v_lhs) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 1117, __pyx_L1_error) + } + + /* "pywrapfst.pyx":1118 + * """ + * return _init_SymbolTable(fst.MergeSymbolTable(deref(lhs._table), + * deref(rhs._table), NULL)) # <<<<<<<<<<<<<< + * + * + */ + if (unlikely(((PyObject *)__pyx_v_rhs) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 1118, __pyx_L1_error) + } + + /* "pywrapfst.pyx":1117 + * See also: `relabel_symbols`. + * """ + * return _init_SymbolTable(fst.MergeSymbolTable(deref(lhs._table), # <<<<<<<<<<<<<< + * deref(rhs._table), NULL)) + * + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_SymbolTable(fst::MergeSymbolTable((*__pyx_v_lhs->_table), (*__pyx_v_rhs->_table), NULL))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = ((struct __pyx_obj_9pywrapfst_SymbolTable *)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":1093 + * + * + * cpdef SymbolTable merge_symbol_table(_SymbolTable lhs, _SymbolTable rhs): # <<<<<<<<<<<<<< + * """ + * merge_symbol_table(lhs, rhs) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.merge_symbol_table", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11merge_symbol_table(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_10merge_symbol_table[] = "\n merge_symbol_table(lhs, rhs)\n\n Merges all symbols from the left table into the right.\n\n This function creates a new SymbolTable which is the merger of the two input\n symbol Tables. Symbols in the right-hand table that conflict with those in the\n left-hand table will be assigned values from the left-hand table. Thus the\n returned table will never modify symbol assignments from the left-hand side,\n but may do so on the right.\n\n If the left-hand table is associated with an FST, it may be necessary to\n relabel it using the output table.\n\n Args:\n lhs: Left-hand side SymbolTable.\n rhs: Left-hand side SymbolTable.\n\n Returns:\n A new merged SymbolTable.\n\n See also: `relabel_symbols`.\n "; +static PyObject *__pyx_pw_9pywrapfst_11merge_symbol_table(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_lhs = 0; + struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_rhs = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("merge_symbol_table (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_lhs,&__pyx_n_s_rhs,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_lhs)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_rhs)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("merge_symbol_table", 1, 2, 2, 1); __PYX_ERR(0, 1093, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "merge_symbol_table") < 0)) __PYX_ERR(0, 1093, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_lhs = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[0]); + __pyx_v_rhs = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[1]); + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("merge_symbol_table", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1093, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.merge_symbol_table", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_lhs), __pyx_ptype_9pywrapfst__SymbolTable, 1, "lhs", 0))) __PYX_ERR(0, 1093, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_rhs), __pyx_ptype_9pywrapfst__SymbolTable, 1, "rhs", 0))) __PYX_ERR(0, 1093, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_10merge_symbol_table(__pyx_self, __pyx_v_lhs, __pyx_v_rhs); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_10merge_symbol_table(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_lhs, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_rhs) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("merge_symbol_table", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_merge_symbol_table(__pyx_v_lhs, __pyx_v_rhs, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1093, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.merge_symbol_table", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1132 + * """ + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "".format(id(self)) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_1__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_1__repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_19SymbolTableIterator___repr__(((struct __pyx_obj_9pywrapfst_SymbolTableIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator___repr__(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "pywrapfst.pyx":1133 + * + * def __repr__(self): + * return "".format(id(self)) # <<<<<<<<<<<<<< + * + * def __init__(self, _SymbolTable syms): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_SymbolTableIterator_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self)); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1133, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1133, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1133, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":1132 + * """ + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "".format(id(self)) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pywrapfst.SymbolTableIterator.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1135 + * return "".format(id(self)) + * + * def __init__(self, _SymbolTable syms): # <<<<<<<<<<<<<< + * self._siter.reset(new fst.SymbolTableIterator(deref(syms._table))) + * + */ + +/* Python wrapper */ +static int __pyx_pw_9pywrapfst_19SymbolTableIterator_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_9pywrapfst_19SymbolTableIterator_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_syms,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_syms)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 1135, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_syms = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[0]); + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1135, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.SymbolTableIterator.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_syms), __pyx_ptype_9pywrapfst__SymbolTable, 1, "syms", 0))) __PYX_ERR(0, 1135, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_19SymbolTableIterator_2__init__(((struct __pyx_obj_9pywrapfst_SymbolTableIterator *)__pyx_v_self), __pyx_v_syms); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pywrapfst_19SymbolTableIterator_2__init__(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__", 0); + + /* "pywrapfst.pyx":1136 + * + * def __init__(self, _SymbolTable syms): + * self._siter.reset(new fst.SymbolTableIterator(deref(syms._table))) # <<<<<<<<<<<<<< + * + * # This just registers this class as a possible iterator. + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_siter"); + __PYX_ERR(0, 1136, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_syms) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 1136, __pyx_L1_error) + } + __pyx_v_self->_siter.reset(new fst::SymbolTableIterator((*__pyx_v_syms->_table))); + + /* "pywrapfst.pyx":1135 + * return "".format(id(self)) + * + * def __init__(self, _SymbolTable syms): # <<<<<<<<<<<<<< + * self._siter.reset(new fst.SymbolTableIterator(deref(syms._table))) + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst.SymbolTableIterator.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1139 + * + * # This just registers this class as a possible iterator. + * def __iter__(self): # <<<<<<<<<<<<<< + * return self + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_5__iter__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_5__iter__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_19SymbolTableIterator_4__iter__(((struct __pyx_obj_9pywrapfst_SymbolTableIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_4__iter__(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__iter__", 0); + + /* "pywrapfst.pyx":1140 + * # This just registers this class as a possible iterator. + * def __iter__(self): + * return self # <<<<<<<<<<<<<< + * + * # Magic method used to get a Pythonic API out of the C++ API. + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":1139 + * + * # This just registers this class as a possible iterator. + * def __iter__(self): # <<<<<<<<<<<<<< + * return self + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1143 + * + * # Magic method used to get a Pythonic API out of the C++ API. + * def __next__(self): # <<<<<<<<<<<<<< + * if self.done(): + * raise StopIteration + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_7__next__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_7__next__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__next__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_19SymbolTableIterator_6__next__(((struct __pyx_obj_9pywrapfst_SymbolTableIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_6__next__(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self) { + __pyx_t_10basictypes_int64 __pyx_v_value; + std::string __pyx_v_symbol; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("__next__", 0); + + /* "pywrapfst.pyx":1144 + * # Magic method used to get a Pythonic API out of the C++ API. + * def __next__(self): + * if self.done(): # <<<<<<<<<<<<<< + * raise StopIteration + * cdef int64 value = self.value() + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "done"); + __PYX_ERR(0, 1144, __pyx_L1_error) + } + __pyx_t_1 = (((struct __pyx_vtabstruct_9pywrapfst_SymbolTableIterator *)__pyx_v_self->__pyx_vtab)->done(__pyx_v_self, 0) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":1145 + * def __next__(self): + * if self.done(): + * raise StopIteration # <<<<<<<<<<<<<< + * cdef int64 value = self.value() + * cdef string symbol = self.symbol() + */ + __Pyx_Raise(__pyx_builtin_StopIteration, 0, 0, 0); + __PYX_ERR(0, 1145, __pyx_L1_error) + + /* "pywrapfst.pyx":1144 + * # Magic method used to get a Pythonic API out of the C++ API. + * def __next__(self): + * if self.done(): # <<<<<<<<<<<<<< + * raise StopIteration + * cdef int64 value = self.value() + */ + } + + /* "pywrapfst.pyx":1146 + * if self.done(): + * raise StopIteration + * cdef int64 value = self.value() # <<<<<<<<<<<<<< + * cdef string symbol = self.symbol() + * self.next() + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "value"); + __PYX_ERR(0, 1146, __pyx_L1_error) + } + __pyx_v_value = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableIterator *)__pyx_v_self->__pyx_vtab)->value(__pyx_v_self, 0); + + /* "pywrapfst.pyx":1147 + * raise StopIteration + * cdef int64 value = self.value() + * cdef string symbol = self.symbol() # <<<<<<<<<<<<<< + * self.next() + * return (value, symbol) + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "symbol"); + __PYX_ERR(0, 1147, __pyx_L1_error) + } + __pyx_v_symbol = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableIterator *)__pyx_v_self->__pyx_vtab)->symbol(__pyx_v_self, 0); + + /* "pywrapfst.pyx":1148 + * cdef int64 value = self.value() + * cdef string symbol = self.symbol() + * self.next() # <<<<<<<<<<<<<< + * return (value, symbol) + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "next"); + __PYX_ERR(0, 1148, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableIterator *)__pyx_v_self->__pyx_vtab)->next(__pyx_v_self, 0); + + /* "pywrapfst.pyx":1149 + * cdef string symbol = self.symbol() + * self.next() + * return (value, symbol) # <<<<<<<<<<<<<< + * + * cpdef bool done(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyInt_From_int64_t(__pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_symbol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":1143 + * + * # Magic method used to get a Pythonic API out of the C++ API. + * def __next__(self): # <<<<<<<<<<<<<< + * if self.done(): + * raise StopIteration + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pywrapfst.SymbolTableIterator.__next__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1151 + * return (value, symbol) + * + * cpdef bool done(self): # <<<<<<<<<<<<<< + * """ + * done(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_9done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static bool __pyx_f_9pywrapfst_19SymbolTableIterator_done(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, int __pyx_skip_dispatch) { + bool __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + bool __pyx_t_5; + __Pyx_RefNannySetupContext("done", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_done); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_9done)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1151, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1151, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1151, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1160 + * True if the iterator is exhausted, False otherwise. + * """ + * return self._siter.get().Done() # <<<<<<<<<<<<<< + * + * cpdef void next(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_siter"); + __PYX_ERR(0, 1160, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_siter.get()->Done(); + goto __pyx_L0; + + /* "pywrapfst.pyx":1151 + * return (value, symbol) + * + * cpdef bool done(self): # <<<<<<<<<<<<<< + * """ + * done(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.SymbolTableIterator.done", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_9done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_19SymbolTableIterator_8done[] = "\n done(self)\n\n Indicates whether the iterator is exhausted or not.\n\n Returns:\n True if the iterator is exhausted, False otherwise.\n "; +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_9done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("done (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_19SymbolTableIterator_8done(((struct __pyx_obj_9pywrapfst_SymbolTableIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_8done(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("done", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_9pywrapfst_19SymbolTableIterator_done(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.SymbolTableIterator.done", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1162 + * return self._siter.get().Done() + * + * cpdef void next(self): # <<<<<<<<<<<<<< + * """ + * next(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_11next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static void __pyx_f_9pywrapfst_19SymbolTableIterator_next(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("next", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_next); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_11next)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1162, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1162, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1168 + * Advances the iterator. + * """ + * self._siter.get().Next() # <<<<<<<<<<<<<< + * + * cpdef void reset(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_siter"); + __PYX_ERR(0, 1168, __pyx_L1_error) + } + __pyx_v_self->_siter.get()->Next(); + + /* "pywrapfst.pyx":1162 + * return self._siter.get().Done() + * + * cpdef void next(self): # <<<<<<<<<<<<<< + * """ + * next(self) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.SymbolTableIterator.next", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_11next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_19SymbolTableIterator_10next[] = "\n next(self)\n\n Advances the iterator.\n "; +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_11next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("next (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_19SymbolTableIterator_10next(((struct __pyx_obj_9pywrapfst_SymbolTableIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_10next(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("next", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_19SymbolTableIterator_next(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.SymbolTableIterator.next", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1170 + * self._siter.get().Next() + * + * cpdef void reset(self): # <<<<<<<<<<<<<< + * """ + * reset(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_13reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static void __pyx_f_9pywrapfst_19SymbolTableIterator_reset(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("reset", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_reset); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_13reset)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1170, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1170, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1176 + * Resets the iterator to the initial position. + * """ + * self._siter.get().Reset() # <<<<<<<<<<<<<< + * + * cpdef string symbol(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_siter"); + __PYX_ERR(0, 1176, __pyx_L1_error) + } + __pyx_v_self->_siter.get()->Reset(); + + /* "pywrapfst.pyx":1170 + * self._siter.get().Next() + * + * cpdef void reset(self): # <<<<<<<<<<<<<< + * """ + * reset(self) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.SymbolTableIterator.reset", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_13reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_19SymbolTableIterator_12reset[] = "\n reset(self)\n\n Resets the iterator to the initial position.\n "; +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_13reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("reset (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_19SymbolTableIterator_12reset(((struct __pyx_obj_9pywrapfst_SymbolTableIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_12reset(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("reset", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_19SymbolTableIterator_reset(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.SymbolTableIterator.reset", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1178 + * self._siter.get().Reset() + * + * cpdef string symbol(self): # <<<<<<<<<<<<<< + * """ + * symbol(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_15symbol(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static std::string __pyx_f_9pywrapfst_19SymbolTableIterator_symbol(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, int __pyx_skip_dispatch) { + std::string __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + std::string __pyx_t_5; + __Pyx_RefNannySetupContext("symbol", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_symbol); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_15symbol)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1178, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1178, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1178, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1189 + * A symbol string. + * """ + * return self._siter.get().Symbol() # <<<<<<<<<<<<<< + * + * cpdef int64 value(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_siter"); + __PYX_ERR(0, 1189, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_siter.get()->Symbol(); + goto __pyx_L0; + + /* "pywrapfst.pyx":1178 + * self._siter.get().Reset() + * + * cpdef string symbol(self): # <<<<<<<<<<<<<< + * """ + * symbol(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.SymbolTableIterator.symbol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_15symbol(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_19SymbolTableIterator_14symbol[] = "\n symbol(self)\n\n Returns the current symbol string.\n\n This method returns the current symbol string at this point in the table.\n\n Returns:\n A symbol string.\n "; +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_15symbol(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("symbol (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_19SymbolTableIterator_14symbol(((struct __pyx_obj_9pywrapfst_SymbolTableIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_14symbol(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("symbol", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_19SymbolTableIterator_symbol(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.SymbolTableIterator.symbol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1191 + * return self._siter.get().Symbol() + * + * cpdef int64 value(self): # <<<<<<<<<<<<<< + * """ + * value(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_17value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_19SymbolTableIterator_value(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, int __pyx_skip_dispatch) { + __pyx_t_10basictypes_int64 __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __pyx_t_10basictypes_int64 __pyx_t_5; + __Pyx_RefNannySetupContext("value", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_17value)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1191, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1191, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1191, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1200 + * An integer index. + * """ + * return self._siter.get().Value() # <<<<<<<<<<<<<< + * + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_siter"); + __PYX_ERR(0, 1200, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_siter.get()->Value(); + goto __pyx_L0; + + /* "pywrapfst.pyx":1191 + * return self._siter.get().Symbol() + * + * cpdef int64 value(self): # <<<<<<<<<<<<<< + * """ + * value(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.SymbolTableIterator.value", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_17value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_19SymbolTableIterator_16value[] = "\n value(self)\n\n Returns the current integer index of the symbol.\n\n Returns:\n An integer index.\n "; +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_17value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("value (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_19SymbolTableIterator_16value(((struct __pyx_obj_9pywrapfst_SymbolTableIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_16value(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("value", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_f_9pywrapfst_19SymbolTableIterator_value(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.SymbolTableIterator.value", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._siter,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_19SymbolTableIterator_18__reduce_cython__(((struct __pyx_obj_9pywrapfst_SymbolTableIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_18__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._siter,self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._siter,self._table cannot be converted to a Python object for pickling") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._siter,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.SymbolTableIterator.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._siter,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._siter,self._table cannot be converted to a Python object for pickling") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_19SymbolTableIterator_20__setstate_cython__(((struct __pyx_obj_9pywrapfst_SymbolTableIterator *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_20__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError("self._siter,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._siter,self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._siter,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._siter,self._table cannot be converted to a Python object for pickling") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.SymbolTableIterator.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1229 + * """ + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "".format(id(self)) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_1__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_1__repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper___repr__(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper___repr__(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "pywrapfst.pyx":1230 + * + * def __repr__(self): + * return "".format(id(self)) # <<<<<<<<<<<<<< + * + * def __init__(self, + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_EncodeMapper_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self)); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1230, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1230, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1230, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":1229 + * """ + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "".format(id(self)) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pywrapfst.EncodeMapper.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1232 + * return "".format(id(self)) + * + * def __init__(self, # <<<<<<<<<<<<<< + * arc_type=b"standard", + * bool encode_labels=False, + */ + +/* Python wrapper */ +static int __pyx_pw_9pywrapfst_12EncodeMapper_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_9pywrapfst_12EncodeMapper_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_arc_type = 0; + bool __pyx_v_encode_labels; + bool __pyx_v_encode_weights; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_arc_type,&__pyx_n_s_encode_labels,&__pyx_n_s_encode_weights,0}; + PyObject* values[3] = {0,0,0}; + values[0] = ((PyObject *)__pyx_n_b_standard); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_arc_type); + if (value) { values[0] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_encode_labels); + if (value) { values[1] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_encode_weights); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 1232, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_arc_type = values[0]; + if (values[1]) { + __pyx_v_encode_labels = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_encode_labels == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1234, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":1234 + * def __init__(self, + * arc_type=b"standard", + * bool encode_labels=False, # <<<<<<<<<<<<<< + * bool encode_weights=False): + * cdef uint32 flags = fst.GetEncodeFlags(encode_labels, encode_weights) + */ + __pyx_v_encode_labels = ((bool)0); + } + if (values[2]) { + __pyx_v_encode_weights = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_encode_weights == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1235, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":1235 + * arc_type=b"standard", + * bool encode_labels=False, + * bool encode_weights=False): # <<<<<<<<<<<<<< + * cdef uint32 flags = fst.GetEncodeFlags(encode_labels, encode_weights) + * self._encoder.reset(new fst.EncodeMapperClass(tostring(arc_type), flags, + */ + __pyx_v_encode_weights = ((bool)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1232, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.EncodeMapper.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_2__init__(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self), __pyx_v_arc_type, __pyx_v_encode_labels, __pyx_v_encode_weights); + + /* "pywrapfst.pyx":1232 + * return "".format(id(self)) + * + * def __init__(self, # <<<<<<<<<<<<<< + * arc_type=b"standard", + * bool encode_labels=False, + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pywrapfst_12EncodeMapper_2__init__(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, PyObject *__pyx_v_arc_type, bool __pyx_v_encode_labels, bool __pyx_v_encode_weights) { + __pyx_t_10basictypes_uint32 __pyx_v_flags; + int __pyx_r; + __Pyx_RefNannyDeclarations + std::string __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "pywrapfst.pyx":1236 + * bool encode_labels=False, + * bool encode_weights=False): + * cdef uint32 flags = fst.GetEncodeFlags(encode_labels, encode_weights) # <<<<<<<<<<<<<< + * self._encoder.reset(new fst.EncodeMapperClass(tostring(arc_type), flags, + * fst.ENCODE)) + */ + __pyx_v_flags = fst::script::GetEncodeFlags(__pyx_v_encode_labels, __pyx_v_encode_weights); + + /* "pywrapfst.pyx":1237 + * bool encode_weights=False): + * cdef uint32 flags = fst.GetEncodeFlags(encode_labels, encode_weights) + * self._encoder.reset(new fst.EncodeMapperClass(tostring(arc_type), flags, # <<<<<<<<<<<<<< + * fst.ENCODE)) + * if not self._encoder: + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_encoder"); + __PYX_ERR(0, 1237, __pyx_L1_error) + } + __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_arc_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1237, __pyx_L1_error) + + /* "pywrapfst.pyx":1238 + * cdef uint32 flags = fst.GetEncodeFlags(encode_labels, encode_weights) + * self._encoder.reset(new fst.EncodeMapperClass(tostring(arc_type), flags, + * fst.ENCODE)) # <<<<<<<<<<<<<< + * if not self._encoder: + * raise FstOpError("Unknown arc type: {!r}".format(arc_type)) + */ + __pyx_v_self->_encoder.reset(new fst::script::EncodeMapperClass(__pyx_t_1, __pyx_v_flags, fst::ENCODE)); + + /* "pywrapfst.pyx":1239 + * self._encoder.reset(new fst.EncodeMapperClass(tostring(arc_type), flags, + * fst.ENCODE)) + * if not self._encoder: # <<<<<<<<<<<<<< + * raise FstOpError("Unknown arc type: {!r}".format(arc_type)) + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_encoder"); + __PYX_ERR(0, 1239, __pyx_L1_error) + } + __pyx_t_2 = ((!__pyx_v_self->_encoder) != 0); + if (__pyx_t_2) { + + /* "pywrapfst.pyx":1240 + * fst.ENCODE)) + * if not self._encoder: + * raise FstOpError("Unknown arc type: {!r}".format(arc_type)) # <<<<<<<<<<<<<< + * + * cpdef string arc_type(self): + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Unknown_arc_type_r, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + if (!__pyx_t_7) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_arc_type); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_arc_type}; + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1240, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_arc_type}; + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1240, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_INCREF(__pyx_v_arc_type); + __Pyx_GIVEREF(__pyx_v_arc_type); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_arc_type); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_6) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1240, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1240, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1240, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 1240, __pyx_L1_error) + + /* "pywrapfst.pyx":1239 + * self._encoder.reset(new fst.EncodeMapperClass(tostring(arc_type), flags, + * fst.ENCODE)) + * if not self._encoder: # <<<<<<<<<<<<<< + * raise FstOpError("Unknown arc type: {!r}".format(arc_type)) + * + */ + } + + /* "pywrapfst.pyx":1232 + * return "".format(id(self)) + * + * def __init__(self, # <<<<<<<<<<<<<< + * arc_type=b"standard", + * bool encode_labels=False, + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pywrapfst.EncodeMapper.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1242 + * raise FstOpError("Unknown arc type: {!r}".format(arc_type)) + * + * cpdef string arc_type(self): # <<<<<<<<<<<<<< + * """ + * arc_type(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_5arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static std::string __pyx_f_9pywrapfst_12EncodeMapper_arc_type(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch) { + std::string __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + std::string __pyx_t_5; + __Pyx_RefNannySetupContext("arc_type", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_arc_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_5arc_type)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1242, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1242, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1242, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1248 + * Returns a string indicating the arc type. + * """ + * return self._encoder.get().ArcType() # <<<<<<<<<<<<<< + * + * # Python's equivalent to operator(). + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_encoder"); + __PYX_ERR(0, 1248, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_encoder.get()->ArcType(); + goto __pyx_L0; + + /* "pywrapfst.pyx":1242 + * raise FstOpError("Unknown arc type: {!r}".format(arc_type)) + * + * cpdef string arc_type(self): # <<<<<<<<<<<<<< + * """ + * arc_type(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.EncodeMapper.arc_type", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_5arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_12EncodeMapper_4arc_type[] = "\n arc_type(self)\n\n Returns a string indicating the arc type.\n "; +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_5arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("arc_type (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_4arc_type(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_4arc_type(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("arc_type", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_12EncodeMapper_arc_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.EncodeMapper.arc_type", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1252 + * # Python's equivalent to operator(). + * + * def __call__(self, Arc arc): # <<<<<<<<<<<<<< + * """ + * self(state, ilabel, olabel, weight, nextstate) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_7__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_12EncodeMapper_6__call__[] = "\n self(state, ilabel, olabel, weight, nextstate)\n\n Uses the encoder to encode an arc.\n\n Args:\n ilabel: The integer index of the input label.\n olabel: The integer index of the output label.\n weight: A Weight or weight string indicating the desired final weight; if\n null, it is set to semiring One.\n nextstate: The integer index of the destination state.\n\n Raises:\n FstOpError: Incompatible or invalid weight.\n "; +#if CYTHON_COMPILING_IN_CPYTHON +struct wrapperbase __pyx_wrapperbase_9pywrapfst_12EncodeMapper_6__call__; +#endif +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_7__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__call__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_arc,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_arc)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__call__") < 0)) __PYX_ERR(0, 1252, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_arc = ((struct __pyx_obj_9pywrapfst_Arc *)values[0]); + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__call__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1252, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.EncodeMapper.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_arc), __pyx_ptype_9pywrapfst_Arc, 1, "arc", 0))) __PYX_ERR(0, 1252, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_6__call__(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self), __pyx_v_arc); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_6__call__(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__call__", 0); + + /* "pywrapfst.pyx":1268 + * FstOpError: Incompatible or invalid weight. + * """ + * return _init_Arc(self._encoder.get().__call__(deref(arc._arc))) # <<<<<<<<<<<<<< + * + * cpdef uint32 flags(self): + */ + __Pyx_XDECREF(__pyx_r); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_encoder"); + __PYX_ERR(0, 1268, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_arc) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_arc"); + __PYX_ERR(0, 1268, __pyx_L1_error) + } + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_Arc(__pyx_v_self->_encoder.get()->operator()((*__pyx_v_arc->_arc)))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":1252 + * # Python's equivalent to operator(). + * + * def __call__(self, Arc arc): # <<<<<<<<<<<<<< + * """ + * self(state, ilabel, olabel, weight, nextstate) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.EncodeMapper.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1270 + * return _init_Arc(self._encoder.get().__call__(deref(arc._arc))) + * + * cpdef uint32 flags(self): # <<<<<<<<<<<<<< + * """ + * flags(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_9flags(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static __pyx_t_10basictypes_uint32 __pyx_f_9pywrapfst_12EncodeMapper_flags(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch) { + __pyx_t_10basictypes_uint32 __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __pyx_t_10basictypes_uint32 __pyx_t_5; + __Pyx_RefNannySetupContext("flags", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_9flags)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1270, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1270, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyInt_As_uint32_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1270, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1276 + * Returns the encoder's flags. + * """ + * return self._encoder.get().Flags() # <<<<<<<<<<<<<< + * + * cpdef _EncodeMapperSymbolTable input_symbols(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_encoder"); + __PYX_ERR(0, 1276, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_encoder.get()->Flags(); + goto __pyx_L0; + + /* "pywrapfst.pyx":1270 + * return _init_Arc(self._encoder.get().__call__(deref(arc._arc))) + * + * cpdef uint32 flags(self): # <<<<<<<<<<<<<< + * """ + * flags(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.EncodeMapper.flags", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_9flags(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_12EncodeMapper_8flags[] = "\n flags(self)\n\n Returns the encoder's flags.\n "; +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_9flags(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("flags (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_8flags(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_8flags(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("flags", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_uint32_t(__pyx_f_9pywrapfst_12EncodeMapper_flags(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.EncodeMapper.flags", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1278 + * return self._encoder.get().Flags() + * + * cpdef _EncodeMapperSymbolTable input_symbols(self): # <<<<<<<<<<<<<< + * """ + * input_symbols(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_11input_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_f_9pywrapfst_12EncodeMapper_input_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch) { + fst::SymbolTable *__pyx_v_syms; + struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + __Pyx_RefNannySetupContext("input_symbols", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_input_symbols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_11input_symbols)) { + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1278, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1278, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pywrapfst__EncodeMapperSymbolTable))))) __PYX_ERR(0, 1278, __pyx_L1_error) + __pyx_r = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *)__pyx_t_2); + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1285 + * """ + * cdef fst.SymbolTable *syms = const_cast[SymbolTable_ptr]( + * self._encoder.get().InputSymbols()) # <<<<<<<<<<<<<< + * if syms == NULL: + * return + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_encoder"); + __PYX_ERR(0, 1285, __pyx_L1_error) + } + + /* "pywrapfst.pyx":1284 + * Returns the encoder's input symbol table, or None if none is present. + * """ + * cdef fst.SymbolTable *syms = const_cast[SymbolTable_ptr]( # <<<<<<<<<<<<<< + * self._encoder.get().InputSymbols()) + * if syms == NULL: + */ + __pyx_v_syms = const_cast<__pyx_t_9pywrapfst_SymbolTable_ptr>(__pyx_v_self->_encoder.get()->InputSymbols()); + + /* "pywrapfst.pyx":1286 + * cdef fst.SymbolTable *syms = const_cast[SymbolTable_ptr]( + * self._encoder.get().InputSymbols()) + * if syms == NULL: # <<<<<<<<<<<<<< + * return + * return _init_EncodeMapperSymbolTable(syms, self._encoder) + */ + __pyx_t_5 = ((__pyx_v_syms == NULL) != 0); + if (__pyx_t_5) { + + /* "pywrapfst.pyx":1287 + * self._encoder.get().InputSymbols()) + * if syms == NULL: + * return # <<<<<<<<<<<<<< + * return _init_EncodeMapperSymbolTable(syms, self._encoder) + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_r = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *)Py_None); __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "pywrapfst.pyx":1286 + * cdef fst.SymbolTable *syms = const_cast[SymbolTable_ptr]( + * self._encoder.get().InputSymbols()) + * if syms == NULL: # <<<<<<<<<<<<<< + * return + * return _init_EncodeMapperSymbolTable(syms, self._encoder) + */ + } + + /* "pywrapfst.pyx":1288 + * if syms == NULL: + * return + * return _init_EncodeMapperSymbolTable(syms, self._encoder) # <<<<<<<<<<<<<< + * + * cpdef _EncodeMapperSymbolTable output_symbols(self): + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_encoder"); + __PYX_ERR(0, 1288, __pyx_L1_error) + } + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_EncodeMapperSymbolTable(__pyx_v_syms, __pyx_v_self->_encoder)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":1278 + * return self._encoder.get().Flags() + * + * cpdef _EncodeMapperSymbolTable input_symbols(self): # <<<<<<<<<<<<<< + * """ + * input_symbols(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pywrapfst.EncodeMapper.input_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_11input_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_12EncodeMapper_10input_symbols[] = "\n input_symbols(self)\n\n Returns the encoder's input symbol table, or None if none is present.\n "; +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_11input_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("input_symbols (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_10input_symbols(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_10input_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("input_symbols", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_12EncodeMapper_input_symbols(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.EncodeMapper.input_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1290 + * return _init_EncodeMapperSymbolTable(syms, self._encoder) + * + * cpdef _EncodeMapperSymbolTable output_symbols(self): # <<<<<<<<<<<<<< + * """ + * output_symbols(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_13output_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_f_9pywrapfst_12EncodeMapper_output_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch) { + fst::SymbolTable *__pyx_v_syms; + struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + __Pyx_RefNannySetupContext("output_symbols", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_output_symbols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_13output_symbols)) { + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1290, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1290, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pywrapfst__EncodeMapperSymbolTable))))) __PYX_ERR(0, 1290, __pyx_L1_error) + __pyx_r = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *)__pyx_t_2); + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1297 + * """ + * cdef fst.SymbolTable *syms = const_cast[SymbolTable_ptr]( + * self._encoder.get().OutputSymbols()) # <<<<<<<<<<<<<< + * if syms == NULL: + * return + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_encoder"); + __PYX_ERR(0, 1297, __pyx_L1_error) + } + + /* "pywrapfst.pyx":1296 + * Returns the encoder's output symbol table, or None if none is present. + * """ + * cdef fst.SymbolTable *syms = const_cast[SymbolTable_ptr]( # <<<<<<<<<<<<<< + * self._encoder.get().OutputSymbols()) + * if syms == NULL: + */ + __pyx_v_syms = const_cast<__pyx_t_9pywrapfst_SymbolTable_ptr>(__pyx_v_self->_encoder.get()->OutputSymbols()); + + /* "pywrapfst.pyx":1298 + * cdef fst.SymbolTable *syms = const_cast[SymbolTable_ptr]( + * self._encoder.get().OutputSymbols()) + * if syms == NULL: # <<<<<<<<<<<<<< + * return + * return _init_EncodeMapperSymbolTable(syms, self._encoder) + */ + __pyx_t_5 = ((__pyx_v_syms == NULL) != 0); + if (__pyx_t_5) { + + /* "pywrapfst.pyx":1299 + * self._encoder.get().OutputSymbols()) + * if syms == NULL: + * return # <<<<<<<<<<<<<< + * return _init_EncodeMapperSymbolTable(syms, self._encoder) + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_r = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *)Py_None); __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "pywrapfst.pyx":1298 + * cdef fst.SymbolTable *syms = const_cast[SymbolTable_ptr]( + * self._encoder.get().OutputSymbols()) + * if syms == NULL: # <<<<<<<<<<<<<< + * return + * return _init_EncodeMapperSymbolTable(syms, self._encoder) + */ + } + + /* "pywrapfst.pyx":1300 + * if syms == NULL: + * return + * return _init_EncodeMapperSymbolTable(syms, self._encoder) # <<<<<<<<<<<<<< + * + * cpdef uint64 properties(self, uint64 mask): + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_encoder"); + __PYX_ERR(0, 1300, __pyx_L1_error) + } + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_EncodeMapperSymbolTable(__pyx_v_syms, __pyx_v_self->_encoder)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1300, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":1290 + * return _init_EncodeMapperSymbolTable(syms, self._encoder) + * + * cpdef _EncodeMapperSymbolTable output_symbols(self): # <<<<<<<<<<<<<< + * """ + * output_symbols(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pywrapfst.EncodeMapper.output_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_13output_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_12EncodeMapper_12output_symbols[] = "\n output_symbols(self)\n\n Returns the encoder's output symbol table, or None if none is present.\n "; +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_13output_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("output_symbols (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_12output_symbols(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_12output_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("output_symbols", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_12EncodeMapper_output_symbols(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.EncodeMapper.output_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1302 + * return _init_EncodeMapperSymbolTable(syms, self._encoder) + * + * cpdef uint64 properties(self, uint64 mask): # <<<<<<<<<<<<<< + * """ + * properties(self, mask) + */ + +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_15properties(PyObject *__pyx_v_self, PyObject *__pyx_arg_mask); /*proto*/ +static __pyx_t_10basictypes_uint64 __pyx_f_9pywrapfst_12EncodeMapper_properties(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_mask, int __pyx_skip_dispatch) { + __pyx_t_10basictypes_uint64 __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + __pyx_t_10basictypes_uint64 __pyx_t_7; + __Pyx_RefNannySetupContext("properties", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_properties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_15properties)) { + __pyx_t_3 = __Pyx_PyInt_From_uint64_t(__pyx_v_mask); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1302, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1302, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1302, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_7 = __Pyx_PyInt_As_uint64_t(__pyx_t_2); if (unlikely((__pyx_t_7 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1302, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_7; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1316 + * A 64-bit bitmask representing the requested properties. + * """ + * return self._encoder.get().Properties(mask) # <<<<<<<<<<<<<< + * + * cpdef void set_input_symbols(self, _SymbolTable syms) except *: + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_encoder"); + __PYX_ERR(0, 1316, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_encoder.get()->Properties(__pyx_v_mask); + goto __pyx_L0; + + /* "pywrapfst.pyx":1302 + * return _init_EncodeMapperSymbolTable(syms, self._encoder) + * + * cpdef uint64 properties(self, uint64 mask): # <<<<<<<<<<<<<< + * """ + * properties(self, mask) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_WriteUnraisable("pywrapfst.EncodeMapper.properties", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_15properties(PyObject *__pyx_v_self, PyObject *__pyx_arg_mask); /*proto*/ +static char __pyx_doc_9pywrapfst_12EncodeMapper_14properties[] = "\n properties(self, mask)\n\n Provides property bits.\n\n This method provides user access to the properties of the encoder.\n\n Args:\n mask: The property mask to be compared to the encoder's properties.\n\n Returns:\n A 64-bit bitmask representing the requested properties.\n "; +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_15properties(PyObject *__pyx_v_self, PyObject *__pyx_arg_mask) { + __pyx_t_10basictypes_uint64 __pyx_v_mask; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("properties (wrapper)", 0); + assert(__pyx_arg_mask); { + __pyx_v_mask = __Pyx_PyInt_As_uint64_t(__pyx_arg_mask); if (unlikely((__pyx_v_mask == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1302, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.EncodeMapper.properties", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_14properties(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self), ((__pyx_t_10basictypes_uint64)__pyx_v_mask)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_14properties(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_mask) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("properties", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_f_9pywrapfst_12EncodeMapper_properties(__pyx_v_self, __pyx_v_mask, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.EncodeMapper.properties", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1318 + * return self._encoder.get().Properties(mask) + * + * cpdef void set_input_symbols(self, _SymbolTable syms) except *: # <<<<<<<<<<<<<< + * """ + * set_input_symbols(self, syms) + */ + +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_17set_input_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_syms); /*proto*/ +static void __pyx_f_9pywrapfst_12EncodeMapper_set_input_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("set_input_symbols", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_input_symbols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_17set_input_symbols)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_syms)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, ((PyObject *)__pyx_v_syms)}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1318, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, ((PyObject *)__pyx_v_syms)}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1318, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(((PyObject *)__pyx_v_syms)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_syms)); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, ((PyObject *)__pyx_v_syms)); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1329 + * See also: `set_output_symbols`. + * """ + * self._encoder.get().SetInputSymbols(syms._table) # <<<<<<<<<<<<<< + * + * cpdef void set_output_symbols(self, _SymbolTable syms) except *: + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_encoder"); + __PYX_ERR(0, 1329, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_syms) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 1329, __pyx_L1_error) + } + __pyx_v_self->_encoder.get()->SetInputSymbols(__pyx_v_syms->_table); + + /* "pywrapfst.pyx":1318 + * return self._encoder.get().Properties(mask) + * + * cpdef void set_input_symbols(self, _SymbolTable syms) except *: # <<<<<<<<<<<<<< + * """ + * set_input_symbols(self, syms) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pywrapfst.EncodeMapper.set_input_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_17set_input_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_syms); /*proto*/ +static char __pyx_doc_9pywrapfst_12EncodeMapper_16set_input_symbols[] = "\n set_input_symbols(self, syms)\n\n Sets the encoder's input symbol table.\n\n Args:\n syms: A SymbolTable.\n\n See also: `set_output_symbols`.\n "; +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_17set_input_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_syms) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_input_symbols (wrapper)", 0); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_syms), __pyx_ptype_9pywrapfst__SymbolTable, 1, "syms", 0))) __PYX_ERR(0, 1318, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_16set_input_symbols(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_syms)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_16set_input_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("set_input_symbols", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_f_9pywrapfst_12EncodeMapper_set_input_symbols(__pyx_v_self, __pyx_v_syms, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1318, __pyx_L1_error) + __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.EncodeMapper.set_input_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1331 + * self._encoder.get().SetInputSymbols(syms._table) + * + * cpdef void set_output_symbols(self, _SymbolTable syms) except *: # <<<<<<<<<<<<<< + * """ + * set_output_symbols(self, syms) + */ + +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_19set_output_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_syms); /*proto*/ +static void __pyx_f_9pywrapfst_12EncodeMapper_set_output_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("set_output_symbols", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_output_symbols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_19set_output_symbols)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_syms)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, ((PyObject *)__pyx_v_syms)}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1331, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, ((PyObject *)__pyx_v_syms)}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1331, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(((PyObject *)__pyx_v_syms)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_syms)); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, ((PyObject *)__pyx_v_syms)); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1342 + * See also: `set_input_symbols`. + * """ + * self._encoder.get().SetOutputSymbols(syms._table) # <<<<<<<<<<<<<< + * + * cpdef string weight_type(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_encoder"); + __PYX_ERR(0, 1342, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_syms) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 1342, __pyx_L1_error) + } + __pyx_v_self->_encoder.get()->SetOutputSymbols(__pyx_v_syms->_table); + + /* "pywrapfst.pyx":1331 + * self._encoder.get().SetInputSymbols(syms._table) + * + * cpdef void set_output_symbols(self, _SymbolTable syms) except *: # <<<<<<<<<<<<<< + * """ + * set_output_symbols(self, syms) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pywrapfst.EncodeMapper.set_output_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_19set_output_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_syms); /*proto*/ +static char __pyx_doc_9pywrapfst_12EncodeMapper_18set_output_symbols[] = "\n set_output_symbols(self, syms)\n\n Sets the encoder's output symbol table.\n\n Args:\n syms: A SymbolTable.\n\n See also: `set_input_symbols`.\n "; +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_19set_output_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_syms) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_output_symbols (wrapper)", 0); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_syms), __pyx_ptype_9pywrapfst__SymbolTable, 1, "syms", 0))) __PYX_ERR(0, 1331, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_18set_output_symbols(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_syms)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_18set_output_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("set_output_symbols", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_f_9pywrapfst_12EncodeMapper_set_output_symbols(__pyx_v_self, __pyx_v_syms, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1331, __pyx_L1_error) + __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.EncodeMapper.set_output_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1344 + * self._encoder.get().SetOutputSymbols(syms._table) + * + * cpdef string weight_type(self): # <<<<<<<<<<<<<< + * """ + * weight_type(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_21weight_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static std::string __pyx_f_9pywrapfst_12EncodeMapper_weight_type(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch) { + std::string __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + std::string __pyx_t_5; + __Pyx_RefNannySetupContext("weight_type", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_weight_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1344, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_21weight_type)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1344, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1344, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1344, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1350 + * Returns a string indicating the weight type. + * """ + * return self._encoder.get().WeightType() # <<<<<<<<<<<<<< + * + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_encoder"); + __PYX_ERR(0, 1350, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_encoder.get()->WeightType(); + goto __pyx_L0; + + /* "pywrapfst.pyx":1344 + * self._encoder.get().SetOutputSymbols(syms._table) + * + * cpdef string weight_type(self): # <<<<<<<<<<<<<< + * """ + * weight_type(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.EncodeMapper.weight_type", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_21weight_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_12EncodeMapper_20weight_type[] = "\n weight_type(self)\n\n Returns a string indicating the weight type.\n "; +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_21weight_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("weight_type (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_20weight_type(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_20weight_type(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("weight_type", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_12EncodeMapper_weight_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1344, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.EncodeMapper.weight_type", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._encoder cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_23__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_23__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_22__reduce_cython__(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_22__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._encoder cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._encoder cannot be converted to a Python object for pickling") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._encoder cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.EncodeMapper.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._encoder cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._encoder cannot be converted to a Python object for pickling") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_25__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_25__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_24__setstate_cython__(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_24__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError("self._encoder cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._encoder cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._encoder cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._encoder cannot be converted to a Python object for pickling") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.EncodeMapper.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1374 + * + * # IPython notebook magic to produce an SVG of the FST. + * def _repr_svg_(self): # <<<<<<<<<<<<<< + * """IPython notebook magic to produce an SVG of the FST using GraphViz. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_1_repr_svg_(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_4_Fst__repr_svg_[] = "IPython notebook magic to produce an SVG of the FST using GraphViz.\n\n This method produces an SVG of the internal graph. Users wishing to create\n publication-quality graphs should instead use the method `draw`, which\n exposes additional parameters.\n\n Raises:\n OSError: Cannot locate the `dot` executable.\n subprocess.CalledProcessError: `dot` returned non-zero exit code.\n\n See also: `draw`, `text`.\n "; +static PyObject *__pyx_pw_9pywrapfst_4_Fst_1_repr_svg_(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_repr_svg_ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_4_Fst__repr_svg_(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4_Fst__repr_svg_(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) { + PyObject *__pyx_v_proc = NULL; + std::stringstream __pyx_v_sstrm; + PyObject *__pyx_v_sout = NULL; + CYTHON_UNUSED PyObject *__pyx_v_serr = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + std::string __pyx_t_6; + std::string __pyx_t_7; + std::string __pyx_t_8; + PyObject *(*__pyx_t_9)(PyObject *); + int __pyx_t_10; + int __pyx_t_11; + PyObject *__pyx_t_12 = NULL; + __Pyx_RefNannySetupContext("_repr_svg_", 0); + + /* "pywrapfst.pyx":1388 + * """ + * # Throws OSError if the dot executable is not found. + * proc = subprocess.Popen(["dot", "-Tsvg"], stdin=subprocess.PIPE, # <<<<<<<<<<<<<< + * stdout=subprocess.PIPE, stderr=subprocess.PIPE) + * cdef stringstream sstrm + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_subprocess); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_Popen); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_dot); + __Pyx_GIVEREF(__pyx_n_s_dot); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_dot); + __Pyx_INCREF(__pyx_kp_s_Tsvg); + __Pyx_GIVEREF(__pyx_kp_s_Tsvg); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_kp_s_Tsvg); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_subprocess); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_PIPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_stdin, __pyx_t_5) < 0) __PYX_ERR(0, 1388, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "pywrapfst.pyx":1389 + * # Throws OSError if the dot executable is not found. + * proc = subprocess.Popen(["dot", "-Tsvg"], stdin=subprocess.PIPE, + * stdout=subprocess.PIPE, stderr=subprocess.PIPE) # <<<<<<<<<<<<<< + * cdef stringstream sstrm + * fst.DrawFst(deref(self._fst), self._fst.get().InputSymbols(), + */ + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_subprocess); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1389, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_PIPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1389, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_stdout, __pyx_t_4) < 0) __PYX_ERR(0, 1388, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_subprocess); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1389, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_PIPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1389, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_stderr, __pyx_t_5) < 0) __PYX_ERR(0, 1388, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "pywrapfst.pyx":1388 + * """ + * # Throws OSError if the dot executable is not found. + * proc = subprocess.Popen(["dot", "-Tsvg"], stdin=subprocess.PIPE, # <<<<<<<<<<<<<< + * stdout=subprocess.PIPE, stderr=subprocess.PIPE) + * cdef stringstream sstrm + */ + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_proc = __pyx_t_5; + __pyx_t_5 = 0; + + /* "pywrapfst.pyx":1391 + * stdout=subprocess.PIPE, stderr=subprocess.PIPE) + * cdef stringstream sstrm + * fst.DrawFst(deref(self._fst), self._fst.get().InputSymbols(), # <<<<<<<<<<<<<< + * self._fst.get().OutputSymbols(), NULL, + * self._fst.get().Properties(fst.kAcceptor, True) == + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1391, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1391, __pyx_L1_error) + } + + /* "pywrapfst.pyx":1392 + * cdef stringstream sstrm + * fst.DrawFst(deref(self._fst), self._fst.get().InputSymbols(), + * self._fst.get().OutputSymbols(), NULL, # <<<<<<<<<<<<<< + * self._fst.get().Properties(fst.kAcceptor, True) == + * fst.kAcceptor, + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1392, __pyx_L1_error) + } + + /* "pywrapfst.pyx":1393 + * fst.DrawFst(deref(self._fst), self._fst.get().InputSymbols(), + * self._fst.get().OutputSymbols(), NULL, + * self._fst.get().Properties(fst.kAcceptor, True) == # <<<<<<<<<<<<<< + * fst.kAcceptor, + * b"", 8.5, 11, True, False, 0.4, 0.25, 14, 5, b"g", False, + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1393, __pyx_L1_error) + } + + /* "pywrapfst.pyx":1395 + * self._fst.get().Properties(fst.kAcceptor, True) == + * fst.kAcceptor, + * b"", 8.5, 11, True, False, 0.4, 0.25, 14, 5, b"g", False, # <<<<<<<<<<<<<< + * addr(sstrm), b"_repr_svg") + * (sout, serr) = proc.communicate(sstrm.str()) + */ + __pyx_t_6 = __pyx_convert_string_from_py_std__in_string(__pyx_kp_b__24); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1395, __pyx_L1_error) + __pyx_t_7 = __pyx_convert_string_from_py_std__in_string(__pyx_n_b_g); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1395, __pyx_L1_error) + + /* "pywrapfst.pyx":1396 + * fst.kAcceptor, + * b"", 8.5, 11, True, False, 0.4, 0.25, 14, 5, b"g", False, + * addr(sstrm), b"_repr_svg") # <<<<<<<<<<<<<< + * (sout, serr) = proc.communicate(sstrm.str()) + * if proc.returncode != 0: # Just to be explicit. + */ + __pyx_t_8 = __pyx_convert_string_from_py_std__in_string(__pyx_n_b_repr_svg); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1396, __pyx_L1_error) + + /* "pywrapfst.pyx":1391 + * stdout=subprocess.PIPE, stderr=subprocess.PIPE) + * cdef stringstream sstrm + * fst.DrawFst(deref(self._fst), self._fst.get().InputSymbols(), # <<<<<<<<<<<<<< + * self._fst.get().OutputSymbols(), NULL, + * self._fst.get().Properties(fst.kAcceptor, True) == + */ + fst::script::DrawFst((*__pyx_v_self->_fst), __pyx_v_self->_fst.get()->InputSymbols(), __pyx_v_self->_fst.get()->OutputSymbols(), NULL, (__pyx_v_self->_fst.get()->Properties(fst::kAcceptor, 1) == fst::kAcceptor), __pyx_t_6, 8.5, 11.0, 1, 0, 0.4, 0.25, 14, 5, __pyx_t_7, 0, (&__pyx_v_sstrm), __pyx_t_8); + + /* "pywrapfst.pyx":1397 + * b"", 8.5, 11, True, False, 0.4, 0.25, 14, 5, b"g", False, + * addr(sstrm), b"_repr_svg") + * (sout, serr) = proc.communicate(sstrm.str()) # <<<<<<<<<<<<<< + * if proc.returncode != 0: # Just to be explicit. + * raise subprocess.CalledProcessError(proc.returncode, self._DOT_TSVG) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_proc, __pyx_n_s_communicate); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1397, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_sstrm.str()); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1397, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + if (!__pyx_t_2) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1397, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_3}; + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1397, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_3}; + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1397, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1397, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1397, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) { + PyObject* sequence = __pyx_t_5; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 1397, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_1 = PyList_GET_ITEM(sequence, 0); + __pyx_t_4 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1397, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1397, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_3 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1397, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_9 = Py_TYPE(__pyx_t_3)->tp_iternext; + index = 0; __pyx_t_1 = __pyx_t_9(__pyx_t_3); if (unlikely(!__pyx_t_1)) goto __pyx_L3_unpacking_failed; + __Pyx_GOTREF(__pyx_t_1); + index = 1; __pyx_t_4 = __pyx_t_9(__pyx_t_3); if (unlikely(!__pyx_t_4)) goto __pyx_L3_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_3), 2) < 0) __PYX_ERR(0, 1397, __pyx_L1_error) + __pyx_t_9 = NULL; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L4_unpacking_done; + __pyx_L3_unpacking_failed:; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_9 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 1397, __pyx_L1_error) + __pyx_L4_unpacking_done:; + } + __pyx_v_sout = __pyx_t_1; + __pyx_t_1 = 0; + __pyx_v_serr = __pyx_t_4; + __pyx_t_4 = 0; + + /* "pywrapfst.pyx":1398 + * addr(sstrm), b"_repr_svg") + * (sout, serr) = proc.communicate(sstrm.str()) + * if proc.returncode != 0: # Just to be explicit. # <<<<<<<<<<<<<< + * raise subprocess.CalledProcessError(proc.returncode, self._DOT_TSVG) + * return sout.decode("utf8") + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_proc, __pyx_n_s_returncode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1398, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_5, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1398, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 1398, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_10) { + + /* "pywrapfst.pyx":1399 + * (sout, serr) = proc.communicate(sstrm.str()) + * if proc.returncode != 0: # Just to be explicit. + * raise subprocess.CalledProcessError(proc.returncode, self._DOT_TSVG) # <<<<<<<<<<<<<< + * return sout.decode("utf8") + * + */ + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_subprocess); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_CalledProcessError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_proc, __pyx_n_s_returncode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_DOT_TSVG); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + __pyx_t_11 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_11 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_5, __pyx_t_3}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1399, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_5, __pyx_t_3}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1399, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_12 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_12, 0+__pyx_t_11, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_11, __pyx_t_3); + __pyx_t_5 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 1399, __pyx_L1_error) + + /* "pywrapfst.pyx":1398 + * addr(sstrm), b"_repr_svg") + * (sout, serr) = proc.communicate(sstrm.str()) + * if proc.returncode != 0: # Just to be explicit. # <<<<<<<<<<<<<< + * raise subprocess.CalledProcessError(proc.returncode, self._DOT_TSVG) + * return sout.decode("utf8") + */ + } + + /* "pywrapfst.pyx":1400 + * if proc.returncode != 0: # Just to be explicit. + * raise subprocess.CalledProcessError(proc.returncode, self._DOT_TSVG) + * return sout.decode("utf8") # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_sout, __pyx_n_s_decode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1400, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1400, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":1374 + * + * # IPython notebook magic to produce an SVG of the FST. + * def _repr_svg_(self): # <<<<<<<<<<<<<< + * """IPython notebook magic to produce an SVG of the FST using GraphViz. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_AddTraceback("pywrapfst._Fst._repr_svg_", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_proc); + __Pyx_XDECREF(__pyx_v_sout); + __Pyx_XDECREF(__pyx_v_serr); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1402 + * return sout.decode("utf8") + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "<{} Fst at 0x{:x}>".format(self.fst_type(), id(self)) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_3__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_3__repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_4_Fst_2__repr__(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4_Fst_2__repr__(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "pywrapfst.pyx":1403 + * + * def __repr__(self): + * return "<{} Fst at 0x{:x}>".format(self.fst_type(), id(self)) # <<<<<<<<<<<<<< + * + * def __init__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Fst_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "fst_type"); + __PYX_ERR(0, 1403, __pyx_L1_error) + } + __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_self->__pyx_vtab)->fst_type(__pyx_v_self, 0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_self)); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1403, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1403, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_5); + __pyx_t_3 = 0; + __pyx_t_5 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":1402 + * return sout.decode("utf8") + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "<{} Fst at 0x{:x}>".format(self.fst_type(), id(self)) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pywrapfst._Fst.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1405 + * return "<{} Fst at 0x{:x}>".format(self.fst_type(), id(self)) + * + * def __init__(self): # <<<<<<<<<<<<<< + * raise FstDeletedConstructorError( + * "Cannot construct {}".format(self.__class__.__name__)) + */ + +/* Python wrapper */ +static int __pyx_pw_9pywrapfst_4_Fst_5__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_9pywrapfst_4_Fst_5__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} + if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; + __pyx_r = __pyx_pf_9pywrapfst_4_Fst_4__init__(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pywrapfst_4_Fst_4__init__(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "pywrapfst.pyx":1406 + * + * def __init__(self): + * raise FstDeletedConstructorError( # <<<<<<<<<<<<<< + * "Cannot construct {}".format(self.__class__.__name__)) + * + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstDeletedConstructorError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1406, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "pywrapfst.pyx":1407 + * def __init__(self): + * raise FstDeletedConstructorError( + * "Cannot construct {}".format(self.__class__.__name__)) # <<<<<<<<<<<<<< + * + * def __str__(self): + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Cannot_construct, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1407, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1407, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1407, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1406, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1406, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1406, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1406, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1406, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 1406, __pyx_L1_error) + + /* "pywrapfst.pyx":1405 + * return "<{} Fst at 0x{:x}>".format(self.fst_type(), id(self)) + * + * def __init__(self): # <<<<<<<<<<<<<< + * raise FstDeletedConstructorError( + * "Cannot construct {}".format(self.__class__.__name__)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pywrapfst._Fst.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1409 + * "Cannot construct {}".format(self.__class__.__name__)) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return self.text() + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_7__str__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_7__str__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_4_Fst_6__str__(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4_Fst_6__str__(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__str__", 0); + + /* "pywrapfst.pyx":1410 + * + * def __str__(self): + * return self.text() # <<<<<<<<<<<<<< + * + * # Registers the class for pickling; must be repeated in any subclass which + */ + __Pyx_XDECREF(__pyx_r); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "text"); + __PYX_ERR(0, 1410, __pyx_L1_error) + } + __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_self->__pyx_vtab)->text(__pyx_v_self, 0, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1410, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":1409 + * "Cannot construct {}".format(self.__class__.__name__)) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return self.text() + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._Fst.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1415 + * # can't be derived by _init_XFst. + * + * def __reduce__(self): # <<<<<<<<<<<<<< + * return (_read_from_string, (self.write_to_string(),)) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_9__reduce__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_9__reduce__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_4_Fst_8__reduce__(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4_Fst_8__reduce__(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("__reduce__", 0); + + /* "pywrapfst.pyx":1416 + * + * def __reduce__(self): + * return (_read_from_string, (self.write_to_string(),)) # <<<<<<<<<<<<<< + * + * cpdef string arc_type(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_read_from_string); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "write_to_string"); + __PYX_ERR(0, 1416, __pyx_L1_error) + } + __pyx_t_2 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_self->__pyx_vtab)->write_to_string(__pyx_v_self, 0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); + __pyx_t_1 = 0; + __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":1415 + * # can't be derived by _init_XFst. + * + * def __reduce__(self): # <<<<<<<<<<<<<< + * return (_read_from_string, (self.write_to_string(),)) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pywrapfst._Fst.__reduce__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1418 + * return (_read_from_string, (self.write_to_string(),)) + * + * cpdef string arc_type(self): # <<<<<<<<<<<<<< + * """ + * arc_type(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_4_Fst_11arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static std::string __pyx_f_9pywrapfst_4_Fst_arc_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch) { + std::string __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + std::string __pyx_t_5; + __Pyx_RefNannySetupContext("arc_type", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_arc_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1418, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_11arc_type)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1418, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1418, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1418, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1424 + * Returns a string indicating the arc type. + * """ + * return self._fst.get().ArcType() # <<<<<<<<<<<<<< + * + * cpdef ArcIterator arcs(self, int64 state): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1424, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_fst.get()->ArcType(); + goto __pyx_L0; + + /* "pywrapfst.pyx":1418 + * return (_read_from_string, (self.write_to_string(),)) + * + * cpdef string arc_type(self): # <<<<<<<<<<<<<< + * """ + * arc_type(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst._Fst.arc_type", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_11arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_4_Fst_10arc_type[] = "\n arc_type(self)\n\n Returns a string indicating the arc type.\n "; +static PyObject *__pyx_pw_9pywrapfst_4_Fst_11arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("arc_type (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_4_Fst_10arc_type(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4_Fst_10arc_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("arc_type", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_4_Fst_arc_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1418, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._Fst.arc_type", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1426 + * return self._fst.get().ArcType() + * + * cpdef ArcIterator arcs(self, int64 state): # <<<<<<<<<<<<<< + * """ + * arcs(self, state) + */ + +static PyObject *__pyx_pw_9pywrapfst_4_Fst_13arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ +static struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_f_9pywrapfst_4_Fst_arcs(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch) { + struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + __Pyx_RefNannySetupContext("arcs", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_arcs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1426, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_13arcs)) { + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_v_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1426, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1426, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1426, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1426, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1426, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1426, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pywrapfst_ArcIterator))))) __PYX_ERR(0, 1426, __pyx_L1_error) + __pyx_r = ((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_t_2); + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1440 + * See also: `mutable_arcs`, `states`. + * """ + * return ArcIterator(self, state) # <<<<<<<<<<<<<< + * + * cpdef _Fst copy(self): + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_v_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1440, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1440, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pywrapfst_ArcIterator), __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1440, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = ((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":1426 + * return self._fst.get().ArcType() + * + * cpdef ArcIterator arcs(self, int64 state): # <<<<<<<<<<<<<< + * """ + * arcs(self, state) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pywrapfst._Fst.arcs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_13arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ +static char __pyx_doc_9pywrapfst_4_Fst_12arcs[] = "\n arcs(self, state)\n\n Returns an iterator over arcs leaving the specified state.\n\n Args:\n state: The source state ID.\n\n Returns:\n An ArcIterator.\n\n See also: `mutable_arcs`, `states`.\n "; +static PyObject *__pyx_pw_9pywrapfst_4_Fst_13arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state) { + __pyx_t_10basictypes_int64 __pyx_v_state; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("arcs (wrapper)", 0); + assert(__pyx_arg_state); { + __pyx_v_state = __Pyx_PyInt_As_int64_t(__pyx_arg_state); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1426, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._Fst.arcs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_4_Fst_12arcs(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), ((__pyx_t_10basictypes_int64)__pyx_v_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4_Fst_12arcs(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("arcs", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_4_Fst_arcs(__pyx_v_self, __pyx_v_state, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1426, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._Fst.arcs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1442 + * return ArcIterator(self, state) + * + * cpdef _Fst copy(self): # <<<<<<<<<<<<<< + * """ + * copy(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_4_Fst_15copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst_4_Fst_copy(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("copy", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_copy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_15copy)) { + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1442, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1442, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pywrapfst__Fst))))) __PYX_ERR(0, 1442, __pyx_L1_error) + __pyx_r = ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_2); + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1448 + * Makes a copy of the FST. + * """ + * return _init_XFst(new fst.FstClass(deref(self._fst))) # <<<<<<<<<<<<<< + * + * cpdef void draw(self, + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1448, __pyx_L1_error) + } + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_XFst(new fst::script::FstClass((*__pyx_v_self->_fst)))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1448, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":1442 + * return ArcIterator(self, state) + * + * cpdef _Fst copy(self): # <<<<<<<<<<<<<< + * """ + * copy(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pywrapfst._Fst.copy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_15copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_4_Fst_14copy[] = "\n copy(self)\n\n Makes a copy of the FST.\n "; +static PyObject *__pyx_pw_9pywrapfst_4_Fst_15copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("copy (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_4_Fst_14copy(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4_Fst_14copy(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("copy", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_4_Fst_copy(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._Fst.copy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1450 + * return _init_XFst(new fst.FstClass(deref(self._fst))) + * + * cpdef void draw(self, # <<<<<<<<<<<<<< + * filename, + * _SymbolTable isymbols=None, + */ + +static PyObject *__pyx_pw_9pywrapfst_4_Fst_17draw(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static void __pyx_f_9pywrapfst_4_Fst_draw(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, PyObject *__pyx_v_filename, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_4_Fst_draw *__pyx_optional_args) { + + /* "pywrapfst.pyx":1452 + * cpdef void draw(self, + * filename, + * _SymbolTable isymbols=None, # <<<<<<<<<<<<<< + * _SymbolTable osymbols=None, + * SymbolTable ssymbols=None, + */ + struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_isymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None); + + /* "pywrapfst.pyx":1453 + * filename, + * _SymbolTable isymbols=None, + * _SymbolTable osymbols=None, # <<<<<<<<<<<<<< + * SymbolTable ssymbols=None, + * bool acceptor=False, + */ + struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_osymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None); + + /* "pywrapfst.pyx":1454 + * _SymbolTable isymbols=None, + * _SymbolTable osymbols=None, + * SymbolTable ssymbols=None, # <<<<<<<<<<<<<< + * bool acceptor=False, + * title=b"", + */ + struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_ssymbols = ((struct __pyx_obj_9pywrapfst_SymbolTable *)Py_None); + + /* "pywrapfst.pyx":1455 + * _SymbolTable osymbols=None, + * SymbolTable ssymbols=None, + * bool acceptor=False, # <<<<<<<<<<<<<< + * title=b"", + * double width=8.5, + */ + bool __pyx_v_acceptor = ((bool)0); + PyObject *__pyx_v_title = ((PyObject *)__pyx_kp_b__24); + double __pyx_v_width = ((double)8.5); + double __pyx_v_height = ((double)11.0); + + /* "pywrapfst.pyx":1459 + * double width=8.5, + * double height=11, + * bool portrait=False, # <<<<<<<<<<<<<< + * bool vertical=False, + * double ranksep=0.4, + */ + bool __pyx_v_portrait = ((bool)0); + + /* "pywrapfst.pyx":1460 + * double height=11, + * bool portrait=False, + * bool vertical=False, # <<<<<<<<<<<<<< + * double ranksep=0.4, + * double nodesep=0.25, + */ + bool __pyx_v_vertical = ((bool)0); + double __pyx_v_ranksep = ((double)0.4); + double __pyx_v_nodesep = ((double)0.25); + __pyx_t_10basictypes_int32 __pyx_v_fontsize = ((__pyx_t_10basictypes_int32)14); + __pyx_t_10basictypes_int32 __pyx_v_precision = ((__pyx_t_10basictypes_int32)5); + PyObject *__pyx_v_float_format = ((PyObject *)__pyx_n_b_g); + + /* "pywrapfst.pyx":1466 + * int32 precision=5, + * float_format=b"g", + * bool show_weight_one=False): # <<<<<<<<<<<<<< + * """ + * draw(self, filename, isymbols=None, osymbols=None, ssymbols=None, + */ + bool __pyx_v_show_weight_one = ((bool)0); + std::string __pyx_v_filename_string; + std::unique_ptr __pyx_v_ostrm; + fst::SymbolTable *__pyx_v_ssymbols_ptr; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + int __pyx_t_15; + PyObject *__pyx_t_16 = NULL; + std::string __pyx_t_17; + int __pyx_t_18; + int __pyx_t_19; + fst::SymbolTable *__pyx_t_20; + fst::SymbolTable const *__pyx_t_21; + fst::SymbolTable const *__pyx_t_22; + std::string __pyx_t_23; + __Pyx_RefNannySetupContext("draw", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_isymbols = __pyx_optional_args->isymbols; + if (__pyx_optional_args->__pyx_n > 1) { + __pyx_v_osymbols = __pyx_optional_args->osymbols; + if (__pyx_optional_args->__pyx_n > 2) { + __pyx_v_ssymbols = __pyx_optional_args->ssymbols; + if (__pyx_optional_args->__pyx_n > 3) { + __pyx_v_acceptor = __pyx_optional_args->acceptor; + if (__pyx_optional_args->__pyx_n > 4) { + __pyx_v_title = __pyx_optional_args->title; + if (__pyx_optional_args->__pyx_n > 5) { + __pyx_v_width = __pyx_optional_args->width; + if (__pyx_optional_args->__pyx_n > 6) { + __pyx_v_height = __pyx_optional_args->height; + if (__pyx_optional_args->__pyx_n > 7) { + __pyx_v_portrait = __pyx_optional_args->portrait; + if (__pyx_optional_args->__pyx_n > 8) { + __pyx_v_vertical = __pyx_optional_args->vertical; + if (__pyx_optional_args->__pyx_n > 9) { + __pyx_v_ranksep = __pyx_optional_args->ranksep; + if (__pyx_optional_args->__pyx_n > 10) { + __pyx_v_nodesep = __pyx_optional_args->nodesep; + if (__pyx_optional_args->__pyx_n > 11) { + __pyx_v_fontsize = __pyx_optional_args->fontsize; + if (__pyx_optional_args->__pyx_n > 12) { + __pyx_v_precision = __pyx_optional_args->precision; + if (__pyx_optional_args->__pyx_n > 13) { + __pyx_v_float_format = __pyx_optional_args->float_format; + if (__pyx_optional_args->__pyx_n > 14) { + __pyx_v_show_weight_one = __pyx_optional_args->show_weight_one; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + + /* "pywrapfst.pyx":1450 + * return _init_XFst(new fst.FstClass(deref(self._fst))) + * + * cpdef void draw(self, # <<<<<<<<<<<<<< + * filename, + * _SymbolTable isymbols=None, + */ + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_draw); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1450, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_17draw)) { + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_acceptor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1450, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_width); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1450, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_height); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1450, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyBool_FromLong(__pyx_v_portrait); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1450, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_vertical); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1450, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = PyFloat_FromDouble(__pyx_v_ranksep); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1450, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = PyFloat_FromDouble(__pyx_v_nodesep); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1450, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyInt_From_int32_t(__pyx_v_fontsize); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1450, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11 = __Pyx_PyInt_From_int32_t(__pyx_v_precision); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1450, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_12 = __Pyx_PyBool_FromLong(__pyx_v_show_weight_one); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1450, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_13 = __pyx_t_1; __pyx_t_14 = NULL; + __pyx_t_15 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) { + __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_13); + if (likely(__pyx_t_14)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); + __Pyx_INCREF(__pyx_t_14); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_13, function); + __pyx_t_15 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_13)) { + PyObject *__pyx_temp[17] = {__pyx_t_14, __pyx_v_filename, ((PyObject *)__pyx_v_isymbols), ((PyObject *)__pyx_v_osymbols), ((PyObject *)__pyx_v_ssymbols), __pyx_t_3, __pyx_v_title, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9, __pyx_t_10, __pyx_t_11, __pyx_v_float_format, __pyx_t_12}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_13, __pyx_temp+1-__pyx_t_15, 16+__pyx_t_15); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1450, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_13)) { + PyObject *__pyx_temp[17] = {__pyx_t_14, __pyx_v_filename, ((PyObject *)__pyx_v_isymbols), ((PyObject *)__pyx_v_osymbols), ((PyObject *)__pyx_v_ssymbols), __pyx_t_3, __pyx_v_title, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9, __pyx_t_10, __pyx_t_11, __pyx_v_float_format, __pyx_t_12}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_13, __pyx_temp+1-__pyx_t_15, 16+__pyx_t_15); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1450, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } else + #endif + { + __pyx_t_16 = PyTuple_New(16+__pyx_t_15); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 1450, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + if (__pyx_t_14) { + __Pyx_GIVEREF(__pyx_t_14); PyTuple_SET_ITEM(__pyx_t_16, 0, __pyx_t_14); __pyx_t_14 = NULL; + } + __Pyx_INCREF(__pyx_v_filename); + __Pyx_GIVEREF(__pyx_v_filename); + PyTuple_SET_ITEM(__pyx_t_16, 0+__pyx_t_15, __pyx_v_filename); + __Pyx_INCREF(((PyObject *)__pyx_v_isymbols)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_isymbols)); + PyTuple_SET_ITEM(__pyx_t_16, 1+__pyx_t_15, ((PyObject *)__pyx_v_isymbols)); + __Pyx_INCREF(((PyObject *)__pyx_v_osymbols)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_osymbols)); + PyTuple_SET_ITEM(__pyx_t_16, 2+__pyx_t_15, ((PyObject *)__pyx_v_osymbols)); + __Pyx_INCREF(((PyObject *)__pyx_v_ssymbols)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_ssymbols)); + PyTuple_SET_ITEM(__pyx_t_16, 3+__pyx_t_15, ((PyObject *)__pyx_v_ssymbols)); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_16, 4+__pyx_t_15, __pyx_t_3); + __Pyx_INCREF(__pyx_v_title); + __Pyx_GIVEREF(__pyx_v_title); + PyTuple_SET_ITEM(__pyx_t_16, 5+__pyx_t_15, __pyx_v_title); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_16, 6+__pyx_t_15, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_16, 7+__pyx_t_15, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_16, 8+__pyx_t_15, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_16, 9+__pyx_t_15, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_16, 10+__pyx_t_15, __pyx_t_8); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_16, 11+__pyx_t_15, __pyx_t_9); + __Pyx_GIVEREF(__pyx_t_10); + PyTuple_SET_ITEM(__pyx_t_16, 12+__pyx_t_15, __pyx_t_10); + __Pyx_GIVEREF(__pyx_t_11); + PyTuple_SET_ITEM(__pyx_t_16, 13+__pyx_t_15, __pyx_t_11); + __Pyx_INCREF(__pyx_v_float_format); + __Pyx_GIVEREF(__pyx_v_float_format); + PyTuple_SET_ITEM(__pyx_t_16, 14+__pyx_t_15, __pyx_v_float_format); + __Pyx_GIVEREF(__pyx_t_12); + PyTuple_SET_ITEM(__pyx_t_16, 15+__pyx_t_15, __pyx_t_12); + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_t_7 = 0; + __pyx_t_8 = 0; + __pyx_t_9 = 0; + __pyx_t_10 = 0; + __pyx_t_11 = 0; + __pyx_t_12 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_t_16, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1450, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + } + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1500 + * See also: `text`. + * """ + * cdef string filename_string = tostring(filename) # <<<<<<<<<<<<<< + * cdef unique_ptr[ofstream] ostrm + * ostrm.reset(new ofstream(filename_string)) + */ + __pyx_t_17 = __pyx_f_9pywrapfst_tostring(__pyx_v_filename, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1500, __pyx_L1_error) + __pyx_v_filename_string = __pyx_t_17; + + /* "pywrapfst.pyx":1502 + * cdef string filename_string = tostring(filename) + * cdef unique_ptr[ofstream] ostrm + * ostrm.reset(new ofstream(filename_string)) # <<<<<<<<<<<<<< + * cdef fst.SymbolTable *ssymbols_ptr = NULL + * if ssymbols is not None: + */ + __pyx_v_ostrm.reset(new std::ofstream(__pyx_v_filename_string)); + + /* "pywrapfst.pyx":1503 + * cdef unique_ptr[ofstream] ostrm + * ostrm.reset(new ofstream(filename_string)) + * cdef fst.SymbolTable *ssymbols_ptr = NULL # <<<<<<<<<<<<<< + * if ssymbols is not None: + * ssymbols_ptr = ssymbols._table + */ + __pyx_v_ssymbols_ptr = NULL; + + /* "pywrapfst.pyx":1504 + * ostrm.reset(new ofstream(filename_string)) + * cdef fst.SymbolTable *ssymbols_ptr = NULL + * if ssymbols is not None: # <<<<<<<<<<<<<< + * ssymbols_ptr = ssymbols._table + * fst.DrawFst(deref(self._fst), + */ + __pyx_t_18 = (((PyObject *)__pyx_v_ssymbols) != Py_None); + __pyx_t_19 = (__pyx_t_18 != 0); + if (__pyx_t_19) { + + /* "pywrapfst.pyx":1505 + * cdef fst.SymbolTable *ssymbols_ptr = NULL + * if ssymbols is not None: + * ssymbols_ptr = ssymbols._table # <<<<<<<<<<<<<< + * fst.DrawFst(deref(self._fst), + * self._fst.get().InputSymbols() if isymbols is None + */ + if (unlikely(((PyObject *)__pyx_v_ssymbols) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 1505, __pyx_L1_error) + } + __pyx_t_20 = __pyx_v_ssymbols->__pyx_base.__pyx_base._table; + __pyx_v_ssymbols_ptr = __pyx_t_20; + + /* "pywrapfst.pyx":1504 + * ostrm.reset(new ofstream(filename_string)) + * cdef fst.SymbolTable *ssymbols_ptr = NULL + * if ssymbols is not None: # <<<<<<<<<<<<<< + * ssymbols_ptr = ssymbols._table + * fst.DrawFst(deref(self._fst), + */ + } + + /* "pywrapfst.pyx":1506 + * if ssymbols is not None: + * ssymbols_ptr = ssymbols._table + * fst.DrawFst(deref(self._fst), # <<<<<<<<<<<<<< + * self._fst.get().InputSymbols() if isymbols is None + * else isymbols._table, + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1506, __pyx_L1_error) + } + + /* "pywrapfst.pyx":1507 + * ssymbols_ptr = ssymbols._table + * fst.DrawFst(deref(self._fst), + * self._fst.get().InputSymbols() if isymbols is None # <<<<<<<<<<<<<< + * else isymbols._table, + * self._fst.get().OutputSymbols() if osymbols is None + */ + __pyx_t_19 = (((PyObject *)__pyx_v_isymbols) == Py_None); + if ((__pyx_t_19 != 0)) { + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1507, __pyx_L1_error) + } + __pyx_t_21 = __pyx_v_self->_fst.get()->InputSymbols(); + } else { + + /* "pywrapfst.pyx":1508 + * fst.DrawFst(deref(self._fst), + * self._fst.get().InputSymbols() if isymbols is None + * else isymbols._table, # <<<<<<<<<<<<<< + * self._fst.get().OutputSymbols() if osymbols is None + * else osymbols._table, + */ + if (unlikely(((PyObject *)__pyx_v_isymbols) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 1508, __pyx_L1_error) + } + __pyx_t_21 = __pyx_v_isymbols->_table; + } + + /* "pywrapfst.pyx":1509 + * self._fst.get().InputSymbols() if isymbols is None + * else isymbols._table, + * self._fst.get().OutputSymbols() if osymbols is None # <<<<<<<<<<<<<< + * else osymbols._table, + * ssymbols_ptr, acceptor, tostring(title), width, height, portrait, + */ + __pyx_t_19 = (((PyObject *)__pyx_v_osymbols) == Py_None); + if ((__pyx_t_19 != 0)) { + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1509, __pyx_L1_error) + } + __pyx_t_22 = __pyx_v_self->_fst.get()->OutputSymbols(); + } else { + + /* "pywrapfst.pyx":1510 + * else isymbols._table, + * self._fst.get().OutputSymbols() if osymbols is None + * else osymbols._table, # <<<<<<<<<<<<<< + * ssymbols_ptr, acceptor, tostring(title), width, height, portrait, + * vertical, ranksep, nodesep, fontsize, precision, + */ + if (unlikely(((PyObject *)__pyx_v_osymbols) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 1510, __pyx_L1_error) + } + __pyx_t_22 = __pyx_v_osymbols->_table; + } + + /* "pywrapfst.pyx":1511 + * self._fst.get().OutputSymbols() if osymbols is None + * else osymbols._table, + * ssymbols_ptr, acceptor, tostring(title), width, height, portrait, # <<<<<<<<<<<<<< + * vertical, ranksep, nodesep, fontsize, precision, + * tostring(float_format), show_weight_one, ostrm.get(), + */ + __pyx_t_17 = __pyx_f_9pywrapfst_tostring(__pyx_v_title, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1511, __pyx_L1_error) + + /* "pywrapfst.pyx":1513 + * ssymbols_ptr, acceptor, tostring(title), width, height, portrait, + * vertical, ranksep, nodesep, fontsize, precision, + * tostring(float_format), show_weight_one, ostrm.get(), # <<<<<<<<<<<<<< + * filename_string) + * + */ + __pyx_t_23 = __pyx_f_9pywrapfst_tostring(__pyx_v_float_format, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1513, __pyx_L1_error) + + /* "pywrapfst.pyx":1506 + * if ssymbols is not None: + * ssymbols_ptr = ssymbols._table + * fst.DrawFst(deref(self._fst), # <<<<<<<<<<<<<< + * self._fst.get().InputSymbols() if isymbols is None + * else isymbols._table, + */ + fst::script::DrawFst((*__pyx_v_self->_fst), __pyx_t_21, __pyx_t_22, __pyx_v_ssymbols_ptr, __pyx_v_acceptor, __pyx_t_17, __pyx_v_width, __pyx_v_height, __pyx_v_portrait, __pyx_v_vertical, __pyx_v_ranksep, __pyx_v_nodesep, __pyx_v_fontsize, __pyx_v_precision, __pyx_t_23, __pyx_v_show_weight_one, __pyx_v_ostrm.get(), __pyx_v_filename_string); + + /* "pywrapfst.pyx":1450 + * return _init_XFst(new fst.FstClass(deref(self._fst))) + * + * cpdef void draw(self, # <<<<<<<<<<<<<< + * filename, + * _SymbolTable isymbols=None, + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_XDECREF(__pyx_t_16); + __Pyx_WriteUnraisable("pywrapfst._Fst.draw", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_17draw(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_4_Fst_16draw[] = "\n draw(self, filename, isymbols=None, osymbols=None, ssymbols=None,\n acceptor=False, title=\"\", width=8.5, height=11, portrait=False,\n vertical=False, ranksep=0.4, nodesep=0.25, fontsize=14,\n precision=5, float_format=\"g\", show_weight_one=False):\n\n Writes out the FST in Graphviz text format.\n\n This method writes out the FST in the dot graph description language. The\n graph can be rendered using the `dot` executable provided by Graphviz.\n\n Args:\n filename: The string location of the output dot/Graphviz file.\n isymbols: An optional symbol table used to label input symbols.\n osymbols: An optional symbol table used to label output symbols.\n ssymbols: An optional symbol table used to label states.\n acceptor: Should the figure be rendered in acceptor format if possible?\n title: An optional string indicating the figure title.\n width: The figure width, in inches.\n height: The figure height, in inches.\n portrait: Should the figure be rendered in portrait rather than\n landscape?\n vertical: Should the figure be rendered bottom-to-top rather than\n left-to-right?\n ranksep: The minimum separation separation between ranks, in inches.\n nodesep: The minimum separation between nodes, in inches.\n fontsize: Font size, in points.\n precision: Numeric precision for floats, in number of chars.\n float_format: One of: 'e', 'f' or 'g'.\n show_weight_one: Should weights equivalent to semiring One be printed?\n\n See also: `text`.\n "; +static PyObject *__pyx_pw_9pywrapfst_4_Fst_17draw(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_filename = 0; + struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_isymbols = 0; + struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_osymbols = 0; + struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_ssymbols = 0; + bool __pyx_v_acceptor; + PyObject *__pyx_v_title = 0; + double __pyx_v_width; + double __pyx_v_height; + bool __pyx_v_portrait; + bool __pyx_v_vertical; + double __pyx_v_ranksep; + double __pyx_v_nodesep; + __pyx_t_10basictypes_int32 __pyx_v_fontsize; + __pyx_t_10basictypes_int32 __pyx_v_precision; + PyObject *__pyx_v_float_format = 0; + bool __pyx_v_show_weight_one; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("draw (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_isymbols,&__pyx_n_s_osymbols,&__pyx_n_s_ssymbols,&__pyx_n_s_acceptor,&__pyx_n_s_title,&__pyx_n_s_width,&__pyx_n_s_height,&__pyx_n_s_portrait,&__pyx_n_s_vertical,&__pyx_n_s_ranksep,&__pyx_n_s_nodesep,&__pyx_n_s_fontsize,&__pyx_n_s_precision,&__pyx_n_s_float_format,&__pyx_n_s_show_weight_one,0}; + PyObject* values[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + + /* "pywrapfst.pyx":1452 + * cpdef void draw(self, + * filename, + * _SymbolTable isymbols=None, # <<<<<<<<<<<<<< + * _SymbolTable osymbols=None, + * SymbolTable ssymbols=None, + */ + values[1] = (PyObject *)((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None); + + /* "pywrapfst.pyx":1453 + * filename, + * _SymbolTable isymbols=None, + * _SymbolTable osymbols=None, # <<<<<<<<<<<<<< + * SymbolTable ssymbols=None, + * bool acceptor=False, + */ + values[2] = (PyObject *)((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None); + + /* "pywrapfst.pyx":1454 + * _SymbolTable isymbols=None, + * _SymbolTable osymbols=None, + * SymbolTable ssymbols=None, # <<<<<<<<<<<<<< + * bool acceptor=False, + * title=b"", + */ + values[3] = (PyObject *)((struct __pyx_obj_9pywrapfst_SymbolTable *)Py_None); + values[5] = ((PyObject *)__pyx_kp_b__24); + values[14] = ((PyObject *)__pyx_n_b_g); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 16: values[15] = PyTuple_GET_ITEM(__pyx_args, 15); + CYTHON_FALLTHROUGH; + case 15: values[14] = PyTuple_GET_ITEM(__pyx_args, 14); + CYTHON_FALLTHROUGH; + case 14: values[13] = PyTuple_GET_ITEM(__pyx_args, 13); + CYTHON_FALLTHROUGH; + case 13: values[12] = PyTuple_GET_ITEM(__pyx_args, 12); + CYTHON_FALLTHROUGH; + case 12: values[11] = PyTuple_GET_ITEM(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_filename)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_isymbols); + if (value) { values[1] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_osymbols); + if (value) { values[2] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ssymbols); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_acceptor); + if (value) { values[4] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_title); + if (value) { values[5] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_width); + if (value) { values[6] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_height); + if (value) { values[7] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 8: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_portrait); + if (value) { values[8] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 9: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_vertical); + if (value) { values[9] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 10: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ranksep); + if (value) { values[10] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 11: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nodesep); + if (value) { values[11] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 12: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_fontsize); + if (value) { values[12] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 13: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_precision); + if (value) { values[13] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 14: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_float_format); + if (value) { values[14] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 15: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_show_weight_one); + if (value) { values[15] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "draw") < 0)) __PYX_ERR(0, 1450, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 16: values[15] = PyTuple_GET_ITEM(__pyx_args, 15); + CYTHON_FALLTHROUGH; + case 15: values[14] = PyTuple_GET_ITEM(__pyx_args, 14); + CYTHON_FALLTHROUGH; + case 14: values[13] = PyTuple_GET_ITEM(__pyx_args, 13); + CYTHON_FALLTHROUGH; + case 13: values[12] = PyTuple_GET_ITEM(__pyx_args, 12); + CYTHON_FALLTHROUGH; + case 12: values[11] = PyTuple_GET_ITEM(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_filename = values[0]; + __pyx_v_isymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[1]); + __pyx_v_osymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[2]); + __pyx_v_ssymbols = ((struct __pyx_obj_9pywrapfst_SymbolTable *)values[3]); + if (values[4]) { + __pyx_v_acceptor = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_acceptor == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1455, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":1455 + * _SymbolTable osymbols=None, + * SymbolTable ssymbols=None, + * bool acceptor=False, # <<<<<<<<<<<<<< + * title=b"", + * double width=8.5, + */ + __pyx_v_acceptor = ((bool)0); + } + __pyx_v_title = values[5]; + if (values[6]) { + __pyx_v_width = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_width == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1457, __pyx_L3_error) + } else { + __pyx_v_width = ((double)8.5); + } + if (values[7]) { + __pyx_v_height = __pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_height == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1458, __pyx_L3_error) + } else { + __pyx_v_height = ((double)11.0); + } + if (values[8]) { + __pyx_v_portrait = __Pyx_PyObject_IsTrue(values[8]); if (unlikely((__pyx_v_portrait == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1459, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":1459 + * double width=8.5, + * double height=11, + * bool portrait=False, # <<<<<<<<<<<<<< + * bool vertical=False, + * double ranksep=0.4, + */ + __pyx_v_portrait = ((bool)0); + } + if (values[9]) { + __pyx_v_vertical = __Pyx_PyObject_IsTrue(values[9]); if (unlikely((__pyx_v_vertical == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1460, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":1460 + * double height=11, + * bool portrait=False, + * bool vertical=False, # <<<<<<<<<<<<<< + * double ranksep=0.4, + * double nodesep=0.25, + */ + __pyx_v_vertical = ((bool)0); + } + if (values[10]) { + __pyx_v_ranksep = __pyx_PyFloat_AsDouble(values[10]); if (unlikely((__pyx_v_ranksep == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1461, __pyx_L3_error) + } else { + __pyx_v_ranksep = ((double)0.4); + } + if (values[11]) { + __pyx_v_nodesep = __pyx_PyFloat_AsDouble(values[11]); if (unlikely((__pyx_v_nodesep == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1462, __pyx_L3_error) + } else { + __pyx_v_nodesep = ((double)0.25); + } + if (values[12]) { + __pyx_v_fontsize = __Pyx_PyInt_As_int32_t(values[12]); if (unlikely((__pyx_v_fontsize == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1463, __pyx_L3_error) + } else { + __pyx_v_fontsize = ((__pyx_t_10basictypes_int32)14); + } + if (values[13]) { + __pyx_v_precision = __Pyx_PyInt_As_int32_t(values[13]); if (unlikely((__pyx_v_precision == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1464, __pyx_L3_error) + } else { + __pyx_v_precision = ((__pyx_t_10basictypes_int32)5); + } + __pyx_v_float_format = values[14]; + if (values[15]) { + __pyx_v_show_weight_one = __Pyx_PyObject_IsTrue(values[15]); if (unlikely((__pyx_v_show_weight_one == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1466, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":1466 + * int32 precision=5, + * float_format=b"g", + * bool show_weight_one=False): # <<<<<<<<<<<<<< + * """ + * draw(self, filename, isymbols=None, osymbols=None, ssymbols=None, + */ + __pyx_v_show_weight_one = ((bool)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("draw", 0, 1, 16, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1450, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._Fst.draw", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_isymbols), __pyx_ptype_9pywrapfst__SymbolTable, 1, "isymbols", 0))) __PYX_ERR(0, 1452, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_osymbols), __pyx_ptype_9pywrapfst__SymbolTable, 1, "osymbols", 0))) __PYX_ERR(0, 1453, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ssymbols), __pyx_ptype_9pywrapfst_SymbolTable, 1, "ssymbols", 0))) __PYX_ERR(0, 1454, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_4_Fst_16draw(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), __pyx_v_filename, __pyx_v_isymbols, __pyx_v_osymbols, __pyx_v_ssymbols, __pyx_v_acceptor, __pyx_v_title, __pyx_v_width, __pyx_v_height, __pyx_v_portrait, __pyx_v_vertical, __pyx_v_ranksep, __pyx_v_nodesep, __pyx_v_fontsize, __pyx_v_precision, __pyx_v_float_format, __pyx_v_show_weight_one); + + /* "pywrapfst.pyx":1450 + * return _init_XFst(new fst.FstClass(deref(self._fst))) + * + * cpdef void draw(self, # <<<<<<<<<<<<<< + * filename, + * _SymbolTable isymbols=None, + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4_Fst_16draw(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, PyObject *__pyx_v_filename, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_isymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_osymbols, struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_ssymbols, bool __pyx_v_acceptor, PyObject *__pyx_v_title, double __pyx_v_width, double __pyx_v_height, bool __pyx_v_portrait, bool __pyx_v_vertical, double __pyx_v_ranksep, double __pyx_v_nodesep, __pyx_t_10basictypes_int32 __pyx_v_fontsize, __pyx_t_10basictypes_int32 __pyx_v_precision, PyObject *__pyx_v_float_format, bool __pyx_v_show_weight_one) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + struct __pyx_opt_args_9pywrapfst_4_Fst_draw __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("draw", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1.__pyx_n = 15; + __pyx_t_1.isymbols = __pyx_v_isymbols; + __pyx_t_1.osymbols = __pyx_v_osymbols; + __pyx_t_1.ssymbols = __pyx_v_ssymbols; + __pyx_t_1.acceptor = __pyx_v_acceptor; + __pyx_t_1.title = __pyx_v_title; + __pyx_t_1.width = __pyx_v_width; + __pyx_t_1.height = __pyx_v_height; + __pyx_t_1.portrait = __pyx_v_portrait; + __pyx_t_1.vertical = __pyx_v_vertical; + __pyx_t_1.ranksep = __pyx_v_ranksep; + __pyx_t_1.nodesep = __pyx_v_nodesep; + __pyx_t_1.fontsize = __pyx_v_fontsize; + __pyx_t_1.precision = __pyx_v_precision; + __pyx_t_1.float_format = __pyx_v_float_format; + __pyx_t_1.show_weight_one = __pyx_v_show_weight_one; + __pyx_vtabptr_9pywrapfst__Fst->draw(__pyx_v_self, __pyx_v_filename, 1, &__pyx_t_1); + __pyx_t_2 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1450, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pywrapfst._Fst.draw", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1516 + * filename_string) + * + * cpdef Weight final(self, int64 state): # <<<<<<<<<<<<<< + * """ + * final(self, state) + */ + +static PyObject *__pyx_pw_9pywrapfst_4_Fst_19final(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ +static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst_4_Fst_final(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch) { + struct __pyx_obj_9pywrapfst_Weight *__pyx_v_weight = 0; + struct __pyx_obj_9pywrapfst_Weight *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + __Pyx_RefNannySetupContext("final", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_final); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1516, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_19final)) { + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_v_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1516, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1516, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1516, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1516, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1516, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1516, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pywrapfst_Weight))))) __PYX_ERR(0, 1516, __pyx_L1_error) + __pyx_r = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_2); + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1531 + * FstIndexError: State index out of range. + * """ + * cdef Weight weight = Weight.__new__(Weight) # <<<<<<<<<<<<<< + * weight._weight.reset(new fst.WeightClass(self._fst.get().Final(state))) + * return weight + */ + __pyx_t_1 = __pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1531, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_Weight)))) __PYX_ERR(0, 1531, __pyx_L1_error) + __pyx_v_weight = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pywrapfst.pyx":1532 + * """ + * cdef Weight weight = Weight.__new__(Weight) + * weight._weight.reset(new fst.WeightClass(self._fst.get().Final(state))) # <<<<<<<<<<<<<< + * return weight + * + */ + if (unlikely(((PyObject *)__pyx_v_weight) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 1532, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1532, __pyx_L1_error) + } + __pyx_v_weight->_weight.reset(new fst::script::WeightClass(__pyx_v_self->_fst.get()->Final(__pyx_v_state))); + + /* "pywrapfst.pyx":1533 + * cdef Weight weight = Weight.__new__(Weight) + * weight._weight.reset(new fst.WeightClass(self._fst.get().Final(state))) + * return weight # <<<<<<<<<<<<<< + * + * cpdef string fst_type(self): + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_weight)); + __pyx_r = __pyx_v_weight; + goto __pyx_L0; + + /* "pywrapfst.pyx":1516 + * filename_string) + * + * cpdef Weight final(self, int64 state): # <<<<<<<<<<<<<< + * """ + * final(self, state) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pywrapfst._Fst.final", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_weight); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_19final(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ +static char __pyx_doc_9pywrapfst_4_Fst_18final[] = "\n final(self, state)\n\n Returns the final weight of a state.\n\n Args:\n state: The integer index of a state.\n\n Returns:\n The final Weight of that state.\n\n Raises:\n FstIndexError: State index out of range.\n "; +static PyObject *__pyx_pw_9pywrapfst_4_Fst_19final(PyObject *__pyx_v_self, PyObject *__pyx_arg_state) { + __pyx_t_10basictypes_int64 __pyx_v_state; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("final (wrapper)", 0); + assert(__pyx_arg_state); { + __pyx_v_state = __Pyx_PyInt_As_int64_t(__pyx_arg_state); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1516, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._Fst.final", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_4_Fst_18final(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), ((__pyx_t_10basictypes_int64)__pyx_v_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4_Fst_18final(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("final", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_4_Fst_final(__pyx_v_self, __pyx_v_state, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1516, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._Fst.final", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1535 + * return weight + * + * cpdef string fst_type(self): # <<<<<<<<<<<<<< + * """ + * fst_type(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_4_Fst_21fst_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static std::string __pyx_f_9pywrapfst_4_Fst_fst_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch) { + std::string __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + std::string __pyx_t_5; + __Pyx_RefNannySetupContext("fst_type", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_fst_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1535, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_21fst_type)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1535, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1535, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1535, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1541 + * Returns a string indicating the FST type. + * """ + * return self._fst.get().FstType() # <<<<<<<<<<<<<< + * + * cpdef _FstSymbolTable input_symbols(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1541, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_fst.get()->FstType(); + goto __pyx_L0; + + /* "pywrapfst.pyx":1535 + * return weight + * + * cpdef string fst_type(self): # <<<<<<<<<<<<<< + * """ + * fst_type(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst._Fst.fst_type", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_21fst_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_4_Fst_20fst_type[] = "\n fst_type(self)\n\n Returns a string indicating the FST type.\n "; +static PyObject *__pyx_pw_9pywrapfst_4_Fst_21fst_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("fst_type (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_4_Fst_20fst_type(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4_Fst_20fst_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("fst_type", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_4_Fst_fst_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1535, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._Fst.fst_type", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1543 + * return self._fst.get().FstType() + * + * cpdef _FstSymbolTable input_symbols(self): # <<<<<<<<<<<<<< + * """ + * input_symbols(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_4_Fst_23input_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_f_9pywrapfst_4_Fst_input_symbols(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch) { + fst::SymbolTable *__pyx_v_syms; + struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + __Pyx_RefNannySetupContext("input_symbols", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_input_symbols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1543, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_23input_symbols)) { + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1543, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1543, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pywrapfst__FstSymbolTable))))) __PYX_ERR(0, 1543, __pyx_L1_error) + __pyx_r = ((struct __pyx_obj_9pywrapfst__FstSymbolTable *)__pyx_t_2); + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1552 + * """ + * cdef fst.SymbolTable *syms = const_cast[SymbolTable_ptr]( + * self._fst.get().InputSymbols()) # <<<<<<<<<<<<<< + * if syms == NULL: + * return + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1552, __pyx_L1_error) + } + + /* "pywrapfst.pyx":1551 + * See also: `input_symbols`. + * """ + * cdef fst.SymbolTable *syms = const_cast[SymbolTable_ptr]( # <<<<<<<<<<<<<< + * self._fst.get().InputSymbols()) + * if syms == NULL: + */ + __pyx_v_syms = const_cast<__pyx_t_9pywrapfst_SymbolTable_ptr>(__pyx_v_self->_fst.get()->InputSymbols()); + + /* "pywrapfst.pyx":1553 + * cdef fst.SymbolTable *syms = const_cast[SymbolTable_ptr]( + * self._fst.get().InputSymbols()) + * if syms == NULL: # <<<<<<<<<<<<<< + * return + * return _init_FstSymbolTable(syms, self._fst) + */ + __pyx_t_5 = ((__pyx_v_syms == NULL) != 0); + if (__pyx_t_5) { + + /* "pywrapfst.pyx":1554 + * self._fst.get().InputSymbols()) + * if syms == NULL: + * return # <<<<<<<<<<<<<< + * return _init_FstSymbolTable(syms, self._fst) + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_r = ((struct __pyx_obj_9pywrapfst__FstSymbolTable *)Py_None); __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "pywrapfst.pyx":1553 + * cdef fst.SymbolTable *syms = const_cast[SymbolTable_ptr]( + * self._fst.get().InputSymbols()) + * if syms == NULL: # <<<<<<<<<<<<<< + * return + * return _init_FstSymbolTable(syms, self._fst) + */ + } + + /* "pywrapfst.pyx":1555 + * if syms == NULL: + * return + * return _init_FstSymbolTable(syms, self._fst) # <<<<<<<<<<<<<< + * + * cpdef size_t num_arcs(self, int64 state) except *: + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1555, __pyx_L1_error) + } + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_FstSymbolTable(__pyx_v_syms, __pyx_v_self->_fst)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1555, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = ((struct __pyx_obj_9pywrapfst__FstSymbolTable *)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":1543 + * return self._fst.get().FstType() + * + * cpdef _FstSymbolTable input_symbols(self): # <<<<<<<<<<<<<< + * """ + * input_symbols(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pywrapfst._Fst.input_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_23input_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_4_Fst_22input_symbols[] = "\n input_symbols(self)\n\n Returns the FST's input symbol table, or None if none is present.\n\n See also: `input_symbols`.\n "; +static PyObject *__pyx_pw_9pywrapfst_4_Fst_23input_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("input_symbols (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_4_Fst_22input_symbols(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4_Fst_22input_symbols(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("input_symbols", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_4_Fst_input_symbols(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1543, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._Fst.input_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1557 + * return _init_FstSymbolTable(syms, self._fst) + * + * cpdef size_t num_arcs(self, int64 state) except *: # <<<<<<<<<<<<<< + * """ + * num_arcs(self, state) + */ + +static PyObject *__pyx_pw_9pywrapfst_4_Fst_25num_arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ +static size_t __pyx_f_9pywrapfst_4_Fst_num_arcs(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch) { + size_t __pyx_v_result; + size_t __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + size_t __pyx_t_7; + int __pyx_t_8; + __Pyx_RefNannySetupContext("num_arcs", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_num_arcs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_25num_arcs)) { + __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_v_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1557, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1557, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1557, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_7 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_7 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 1557, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_7; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1574 + * See also: `num_states`. + * """ + * cdef size_t result = self._fst.get().NumArcs(state) # <<<<<<<<<<<<<< + * if result == SIZE_MAX: + * raise FstIndexError("State index out of range") + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1574, __pyx_L1_error) + } + __pyx_v_result = __pyx_v_self->_fst.get()->NumArcs(__pyx_v_state); + + /* "pywrapfst.pyx":1575 + * """ + * cdef size_t result = self._fst.get().NumArcs(state) + * if result == SIZE_MAX: # <<<<<<<<<<<<<< + * raise FstIndexError("State index out of range") + * return result + */ + __pyx_t_8 = ((__pyx_v_result == SIZE_MAX) != 0); + if (__pyx_t_8) { + + /* "pywrapfst.pyx":1576 + * cdef size_t result = self._fst.get().NumArcs(state) + * if result == SIZE_MAX: + * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1576, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1576, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1576, __pyx_L1_error) + + /* "pywrapfst.pyx":1575 + * """ + * cdef size_t result = self._fst.get().NumArcs(state) + * if result == SIZE_MAX: # <<<<<<<<<<<<<< + * raise FstIndexError("State index out of range") + * return result + */ + } + + /* "pywrapfst.pyx":1577 + * if result == SIZE_MAX: + * raise FstIndexError("State index out of range") + * return result # <<<<<<<<<<<<<< + * + * cpdef size_t num_input_epsilons(self, int64 state) except *: + */ + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "pywrapfst.pyx":1557 + * return _init_FstSymbolTable(syms, self._fst) + * + * cpdef size_t num_arcs(self, int64 state) except *: # <<<<<<<<<<<<<< + * """ + * num_arcs(self, state) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pywrapfst._Fst.num_arcs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_25num_arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ +static char __pyx_doc_9pywrapfst_4_Fst_24num_arcs[] = "\n num_arcs(self, state)\n\n Returns the number of arcs leaving a state.\n\n Args:\n state: The integer index of a state.\n\n Returns:\n The number of arcs leaving that state.\n\n Raises:\n FstIndexError: State index out of range.\n\n See also: `num_states`.\n "; +static PyObject *__pyx_pw_9pywrapfst_4_Fst_25num_arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state) { + __pyx_t_10basictypes_int64 __pyx_v_state; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("num_arcs (wrapper)", 0); + assert(__pyx_arg_state); { + __pyx_v_state = __Pyx_PyInt_As_int64_t(__pyx_arg_state); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1557, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._Fst.num_arcs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_4_Fst_24num_arcs(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), ((__pyx_t_10basictypes_int64)__pyx_v_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4_Fst_24num_arcs(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + size_t __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("num_arcs", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pywrapfst_4_Fst_num_arcs(__pyx_v_self, __pyx_v_state, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1557, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_FromSize_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pywrapfst._Fst.num_arcs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1579 + * return result + * + * cpdef size_t num_input_epsilons(self, int64 state) except *: # <<<<<<<<<<<<<< + * """ + * num_input_epsilons(self, state) + */ + +static PyObject *__pyx_pw_9pywrapfst_4_Fst_27num_input_epsilons(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ +static size_t __pyx_f_9pywrapfst_4_Fst_num_input_epsilons(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch) { + size_t __pyx_v_result; + size_t __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + size_t __pyx_t_7; + int __pyx_t_8; + __Pyx_RefNannySetupContext("num_input_epsilons", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_num_input_epsilons); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_27num_input_epsilons)) { + __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_v_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1579, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1579, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1579, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_7 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_7 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 1579, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_7; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1596 + * See also: `num_output_epsilons`. + * """ + * cdef size_t result = self._fst.get().NumInputEpsilons(state) # <<<<<<<<<<<<<< + * if result == SIZE_MAX: + * raise FstIndexError("State index out of range") + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1596, __pyx_L1_error) + } + __pyx_v_result = __pyx_v_self->_fst.get()->NumInputEpsilons(__pyx_v_state); + + /* "pywrapfst.pyx":1597 + * """ + * cdef size_t result = self._fst.get().NumInputEpsilons(state) + * if result == SIZE_MAX: # <<<<<<<<<<<<<< + * raise FstIndexError("State index out of range") + * return result + */ + __pyx_t_8 = ((__pyx_v_result == SIZE_MAX) != 0); + if (__pyx_t_8) { + + /* "pywrapfst.pyx":1598 + * cdef size_t result = self._fst.get().NumInputEpsilons(state) + * if result == SIZE_MAX: + * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1598, __pyx_L1_error) + + /* "pywrapfst.pyx":1597 + * """ + * cdef size_t result = self._fst.get().NumInputEpsilons(state) + * if result == SIZE_MAX: # <<<<<<<<<<<<<< + * raise FstIndexError("State index out of range") + * return result + */ + } + + /* "pywrapfst.pyx":1599 + * if result == SIZE_MAX: + * raise FstIndexError("State index out of range") + * return result # <<<<<<<<<<<<<< + * + * cpdef size_t num_output_epsilons(self, int64 state) except *: + */ + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "pywrapfst.pyx":1579 + * return result + * + * cpdef size_t num_input_epsilons(self, int64 state) except *: # <<<<<<<<<<<<<< + * """ + * num_input_epsilons(self, state) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pywrapfst._Fst.num_input_epsilons", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_27num_input_epsilons(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ +static char __pyx_doc_9pywrapfst_4_Fst_26num_input_epsilons[] = "\n num_input_epsilons(self, state)\n\n Returns the number of arcs with epsilon input labels leaving a state.\n\n Args:\n state: The integer index of a state.\n\n Returns:\n The number of epsilon-input-labeled arcs leaving that state.\n\n Raises:\n FstIndexError: State index out of range.\n\n See also: `num_output_epsilons`.\n "; +static PyObject *__pyx_pw_9pywrapfst_4_Fst_27num_input_epsilons(PyObject *__pyx_v_self, PyObject *__pyx_arg_state) { + __pyx_t_10basictypes_int64 __pyx_v_state; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("num_input_epsilons (wrapper)", 0); + assert(__pyx_arg_state); { + __pyx_v_state = __Pyx_PyInt_As_int64_t(__pyx_arg_state); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1579, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._Fst.num_input_epsilons", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_4_Fst_26num_input_epsilons(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), ((__pyx_t_10basictypes_int64)__pyx_v_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4_Fst_26num_input_epsilons(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + size_t __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("num_input_epsilons", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pywrapfst_4_Fst_num_input_epsilons(__pyx_v_self, __pyx_v_state, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1579, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_FromSize_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pywrapfst._Fst.num_input_epsilons", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1601 + * return result + * + * cpdef size_t num_output_epsilons(self, int64 state) except *: # <<<<<<<<<<<<<< + * """ + * num_output_epsilons(self, state) + */ + +static PyObject *__pyx_pw_9pywrapfst_4_Fst_29num_output_epsilons(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ +static size_t __pyx_f_9pywrapfst_4_Fst_num_output_epsilons(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch) { + size_t __pyx_v_result; + size_t __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + size_t __pyx_t_7; + int __pyx_t_8; + __Pyx_RefNannySetupContext("num_output_epsilons", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_num_output_epsilons); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_29num_output_epsilons)) { + __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_v_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1601, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1601, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1601, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_7 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_7 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 1601, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_7; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1618 + * See also: `num_input_epsilons`. + * """ + * cdef size_t result = self._fst.get().NumOutputEpsilons(state) # <<<<<<<<<<<<<< + * if result == SIZE_MAX: + * raise FstIndexError("State index out of range") + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1618, __pyx_L1_error) + } + __pyx_v_result = __pyx_v_self->_fst.get()->NumOutputEpsilons(__pyx_v_state); + + /* "pywrapfst.pyx":1619 + * """ + * cdef size_t result = self._fst.get().NumOutputEpsilons(state) + * if result == SIZE_MAX: # <<<<<<<<<<<<<< + * raise FstIndexError("State index out of range") + * return result + */ + __pyx_t_8 = ((__pyx_v_result == SIZE_MAX) != 0); + if (__pyx_t_8) { + + /* "pywrapfst.pyx":1620 + * cdef size_t result = self._fst.get().NumOutputEpsilons(state) + * if result == SIZE_MAX: + * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1620, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__28, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1620, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1620, __pyx_L1_error) + + /* "pywrapfst.pyx":1619 + * """ + * cdef size_t result = self._fst.get().NumOutputEpsilons(state) + * if result == SIZE_MAX: # <<<<<<<<<<<<<< + * raise FstIndexError("State index out of range") + * return result + */ + } + + /* "pywrapfst.pyx":1621 + * if result == SIZE_MAX: + * raise FstIndexError("State index out of range") + * return result # <<<<<<<<<<<<<< + * + * cpdef _FstSymbolTable output_symbols(self): + */ + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "pywrapfst.pyx":1601 + * return result + * + * cpdef size_t num_output_epsilons(self, int64 state) except *: # <<<<<<<<<<<<<< + * """ + * num_output_epsilons(self, state) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pywrapfst._Fst.num_output_epsilons", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_29num_output_epsilons(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ +static char __pyx_doc_9pywrapfst_4_Fst_28num_output_epsilons[] = "\n num_output_epsilons(self, state)\n\n Returns the number of arcs with epsilon output labels leaving a state.\n\n Args:\n state: The integer index of a state.\n\n Returns:\n The number of epsilon-output-labeled arcs leaving that state.\n\n Raises:\n FstIndexError: State index out of range.\n\n See also: `num_input_epsilons`.\n "; +static PyObject *__pyx_pw_9pywrapfst_4_Fst_29num_output_epsilons(PyObject *__pyx_v_self, PyObject *__pyx_arg_state) { + __pyx_t_10basictypes_int64 __pyx_v_state; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("num_output_epsilons (wrapper)", 0); + assert(__pyx_arg_state); { + __pyx_v_state = __Pyx_PyInt_As_int64_t(__pyx_arg_state); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1601, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._Fst.num_output_epsilons", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_4_Fst_28num_output_epsilons(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), ((__pyx_t_10basictypes_int64)__pyx_v_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4_Fst_28num_output_epsilons(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + size_t __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("num_output_epsilons", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pywrapfst_4_Fst_num_output_epsilons(__pyx_v_self, __pyx_v_state, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1601, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_FromSize_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pywrapfst._Fst.num_output_epsilons", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1623 + * return result + * + * cpdef _FstSymbolTable output_symbols(self): # <<<<<<<<<<<<<< + * """ + * output_symbols(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_4_Fst_31output_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_f_9pywrapfst_4_Fst_output_symbols(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch) { + fst::SymbolTable *__pyx_v_syms; + struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + __Pyx_RefNannySetupContext("output_symbols", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_output_symbols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1623, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_31output_symbols)) { + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1623, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1623, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pywrapfst__FstSymbolTable))))) __PYX_ERR(0, 1623, __pyx_L1_error) + __pyx_r = ((struct __pyx_obj_9pywrapfst__FstSymbolTable *)__pyx_t_2); + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1632 + * """ + * cdef fst.SymbolTable *syms = const_cast[SymbolTable_ptr]( + * self._fst.get().OutputSymbols()) # <<<<<<<<<<<<<< + * if syms == NULL: + * return + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1632, __pyx_L1_error) + } + + /* "pywrapfst.pyx":1631 + * See also: `input_symbols`. + * """ + * cdef fst.SymbolTable *syms = const_cast[SymbolTable_ptr]( # <<<<<<<<<<<<<< + * self._fst.get().OutputSymbols()) + * if syms == NULL: + */ + __pyx_v_syms = const_cast<__pyx_t_9pywrapfst_SymbolTable_ptr>(__pyx_v_self->_fst.get()->OutputSymbols()); + + /* "pywrapfst.pyx":1633 + * cdef fst.SymbolTable *syms = const_cast[SymbolTable_ptr]( + * self._fst.get().OutputSymbols()) + * if syms == NULL: # <<<<<<<<<<<<<< + * return + * return _init_FstSymbolTable(syms, self._fst) + */ + __pyx_t_5 = ((__pyx_v_syms == NULL) != 0); + if (__pyx_t_5) { + + /* "pywrapfst.pyx":1634 + * self._fst.get().OutputSymbols()) + * if syms == NULL: + * return # <<<<<<<<<<<<<< + * return _init_FstSymbolTable(syms, self._fst) + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_r = ((struct __pyx_obj_9pywrapfst__FstSymbolTable *)Py_None); __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "pywrapfst.pyx":1633 + * cdef fst.SymbolTable *syms = const_cast[SymbolTable_ptr]( + * self._fst.get().OutputSymbols()) + * if syms == NULL: # <<<<<<<<<<<<<< + * return + * return _init_FstSymbolTable(syms, self._fst) + */ + } + + /* "pywrapfst.pyx":1635 + * if syms == NULL: + * return + * return _init_FstSymbolTable(syms, self._fst) # <<<<<<<<<<<<<< + * + * cpdef uint64 properties(self, uint64 mask, bool test): + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1635, __pyx_L1_error) + } + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_FstSymbolTable(__pyx_v_syms, __pyx_v_self->_fst)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = ((struct __pyx_obj_9pywrapfst__FstSymbolTable *)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":1623 + * return result + * + * cpdef _FstSymbolTable output_symbols(self): # <<<<<<<<<<<<<< + * """ + * output_symbols(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pywrapfst._Fst.output_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_31output_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_4_Fst_30output_symbols[] = "\n output_symbols(self)\n\n Returns the FST's output symbol table, or None if none is present.\n\n See also: `input_symbols`.\n "; +static PyObject *__pyx_pw_9pywrapfst_4_Fst_31output_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("output_symbols (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_4_Fst_30output_symbols(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4_Fst_30output_symbols(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("output_symbols", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_4_Fst_output_symbols(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1623, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._Fst.output_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1637 + * return _init_FstSymbolTable(syms, self._fst) + * + * cpdef uint64 properties(self, uint64 mask, bool test): # <<<<<<<<<<<<<< + * """ + * properties(self, mask, test) + */ + +static PyObject *__pyx_pw_9pywrapfst_4_Fst_33properties(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static __pyx_t_10basictypes_uint64 __pyx_f_9pywrapfst_4_Fst_properties(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_mask, bool __pyx_v_test, int __pyx_skip_dispatch) { + __pyx_t_10basictypes_uint64 __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + __pyx_t_10basictypes_uint64 __pyx_t_9; + __Pyx_RefNannySetupContext("properties", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_properties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1637, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_33properties)) { + __pyx_t_3 = __Pyx_PyInt_From_uint64_t(__pyx_v_mask); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1637, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_test); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1637, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_5 = __pyx_t_1; __pyx_t_6 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1637, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1637, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1637, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_6) { + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; + } + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_4); + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1637, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_9 = __Pyx_PyInt_As_uint64_t(__pyx_t_2); if (unlikely((__pyx_t_9 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1637, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_9; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1655 + * A 64-bit bitmask representing the requested properties. + * """ + * return self._fst.get().Properties(mask, test) # <<<<<<<<<<<<<< + * + * cpdef int64 start(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1655, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_fst.get()->Properties(__pyx_v_mask, __pyx_v_test); + goto __pyx_L0; + + /* "pywrapfst.pyx":1637 + * return _init_FstSymbolTable(syms, self._fst) + * + * cpdef uint64 properties(self, uint64 mask, bool test): # <<<<<<<<<<<<<< + * """ + * properties(self, mask, test) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_WriteUnraisable("pywrapfst._Fst.properties", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_33properties(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_4_Fst_32properties[] = "\n properties(self, mask, test)\n\n Provides property bits.\n\n This method provides user access to the properties attributes for the FST.\n The resulting value is a long integer, but when it is cast to a boolean,\n it represents whether or not the FST has the `mask` property.\n\n Args:\n mask: The property mask to be compared to the FST's properties.\n test: Should any unknown values be computed before comparing against\n the mask?\n\n Returns:\n A 64-bit bitmask representing the requested properties.\n "; +static PyObject *__pyx_pw_9pywrapfst_4_Fst_33properties(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + __pyx_t_10basictypes_uint64 __pyx_v_mask; + bool __pyx_v_test; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("properties (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_mask,&__pyx_n_s_test,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mask)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_test)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("properties", 1, 2, 2, 1); __PYX_ERR(0, 1637, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "properties") < 0)) __PYX_ERR(0, 1637, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_mask = __Pyx_PyInt_As_uint64_t(values[0]); if (unlikely((__pyx_v_mask == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1637, __pyx_L3_error) + __pyx_v_test = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_test == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1637, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("properties", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1637, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._Fst.properties", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_4_Fst_32properties(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), __pyx_v_mask, __pyx_v_test); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4_Fst_32properties(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_mask, bool __pyx_v_test) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("properties", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_f_9pywrapfst_4_Fst_properties(__pyx_v_self, __pyx_v_mask, __pyx_v_test, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1637, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._Fst.properties", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1657 + * return self._fst.get().Properties(mask, test) + * + * cpdef int64 start(self): # <<<<<<<<<<<<<< + * """ + * start(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_4_Fst_35start(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_4_Fst_start(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch) { + __pyx_t_10basictypes_int64 __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __pyx_t_10basictypes_int64 __pyx_t_5; + __Pyx_RefNannySetupContext("start", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_start); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1657, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_35start)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1657, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1657, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1657, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1663 + * Returns the start state. + * """ + * return self._fst.get().Start() # <<<<<<<<<<<<<< + * + * cpdef StateIterator states(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1663, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_fst.get()->Start(); + goto __pyx_L0; + + /* "pywrapfst.pyx":1657 + * return self._fst.get().Properties(mask, test) + * + * cpdef int64 start(self): # <<<<<<<<<<<<<< + * """ + * start(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst._Fst.start", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_35start(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_4_Fst_34start[] = "\n start(self)\n\n Returns the start state.\n "; +static PyObject *__pyx_pw_9pywrapfst_4_Fst_35start(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("start (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_4_Fst_34start(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4_Fst_34start(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("start", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_f_9pywrapfst_4_Fst_start(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1657, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._Fst.start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1665 + * return self._fst.get().Start() + * + * cpdef StateIterator states(self): # <<<<<<<<<<<<<< + * """ + * states(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_4_Fst_37states(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static struct __pyx_obj_9pywrapfst_StateIterator *__pyx_f_9pywrapfst_4_Fst_states(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch) { + struct __pyx_obj_9pywrapfst_StateIterator *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("states", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_states); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1665, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_37states)) { + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1665, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1665, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pywrapfst_StateIterator))))) __PYX_ERR(0, 1665, __pyx_L1_error) + __pyx_r = ((struct __pyx_obj_9pywrapfst_StateIterator *)__pyx_t_2); + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1676 + * See also: `arcs`, `mutable_arcs`. + * """ + * return StateIterator(self) # <<<<<<<<<<<<<< + * + * cpdef string text(self, _SymbolTable isymbols=None, + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1676, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self)); + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pywrapfst_StateIterator), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1676, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = ((struct __pyx_obj_9pywrapfst_StateIterator *)__pyx_t_2); + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":1665 + * return self._fst.get().Start() + * + * cpdef StateIterator states(self): # <<<<<<<<<<<<<< + * """ + * states(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pywrapfst._Fst.states", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_37states(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_4_Fst_36states[] = "\n states(self)\n\n Returns an iterator over all states in the FST.\n\n Returns:\n A StateIterator object for the FST.\n\n See also: `arcs`, `mutable_arcs`.\n "; +static PyObject *__pyx_pw_9pywrapfst_4_Fst_37states(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("states (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_4_Fst_36states(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4_Fst_36states(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("states", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_4_Fst_states(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1665, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._Fst.states", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1678 + * return StateIterator(self) + * + * cpdef string text(self, _SymbolTable isymbols=None, # <<<<<<<<<<<<<< + * _SymbolTable osymbols=None, _SymbolTable ssymbols=None, + * bool acceptor=False, bool show_weight_one=False, missing_sym=b""): + */ + +static PyObject *__pyx_pw_9pywrapfst_4_Fst_39text(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static std::string __pyx_f_9pywrapfst_4_Fst_text(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_4_Fst_text *__pyx_optional_args) { + struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_isymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None); + + /* "pywrapfst.pyx":1679 + * + * cpdef string text(self, _SymbolTable isymbols=None, + * _SymbolTable osymbols=None, _SymbolTable ssymbols=None, # <<<<<<<<<<<<<< + * bool acceptor=False, bool show_weight_one=False, missing_sym=b""): + * """ + */ + struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_osymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None); + struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_ssymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None); + + /* "pywrapfst.pyx":1680 + * cpdef string text(self, _SymbolTable isymbols=None, + * _SymbolTable osymbols=None, _SymbolTable ssymbols=None, + * bool acceptor=False, bool show_weight_one=False, missing_sym=b""): # <<<<<<<<<<<<<< + * """ + * text(self, isymbols=None, osymbols=None, ssymbols=None, acceptor=False, + */ + bool __pyx_v_acceptor = ((bool)0); + bool __pyx_v_show_weight_one = ((bool)0); + PyObject *__pyx_v_missing_sym = ((PyObject *)__pyx_kp_b__24); + fst::SymbolTable *__pyx_v_ssymbols_ptr; + std::stringstream __pyx_v_sstrm; + std::string __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + std::string __pyx_t_9; + int __pyx_t_10; + int __pyx_t_11; + fst::SymbolTable *__pyx_t_12; + fst::SymbolTable const *__pyx_t_13; + fst::SymbolTable const *__pyx_t_14; + std::string __pyx_t_15; + __Pyx_RefNannySetupContext("text", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_isymbols = __pyx_optional_args->isymbols; + if (__pyx_optional_args->__pyx_n > 1) { + __pyx_v_osymbols = __pyx_optional_args->osymbols; + if (__pyx_optional_args->__pyx_n > 2) { + __pyx_v_ssymbols = __pyx_optional_args->ssymbols; + if (__pyx_optional_args->__pyx_n > 3) { + __pyx_v_acceptor = __pyx_optional_args->acceptor; + if (__pyx_optional_args->__pyx_n > 4) { + __pyx_v_show_weight_one = __pyx_optional_args->show_weight_one; + if (__pyx_optional_args->__pyx_n > 5) { + __pyx_v_missing_sym = __pyx_optional_args->missing_sym; + } + } + } + } + } + } + } + + /* "pywrapfst.pyx":1678 + * return StateIterator(self) + * + * cpdef string text(self, _SymbolTable isymbols=None, # <<<<<<<<<<<<<< + * _SymbolTable osymbols=None, _SymbolTable ssymbols=None, + * bool acceptor=False, bool show_weight_one=False, missing_sym=b""): + */ + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_text); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1678, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_39text)) { + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_acceptor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1678, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_show_weight_one); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1678, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_5 = __pyx_t_1; __pyx_t_6 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[7] = {__pyx_t_6, ((PyObject *)__pyx_v_isymbols), ((PyObject *)__pyx_v_osymbols), ((PyObject *)__pyx_v_ssymbols), __pyx_t_3, __pyx_t_4, __pyx_v_missing_sym}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 6+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1678, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[7] = {__pyx_t_6, ((PyObject *)__pyx_v_isymbols), ((PyObject *)__pyx_v_osymbols), ((PyObject *)__pyx_v_ssymbols), __pyx_t_3, __pyx_t_4, __pyx_v_missing_sym}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 6+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1678, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(6+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1678, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_6) { + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; + } + __Pyx_INCREF(((PyObject *)__pyx_v_isymbols)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_isymbols)); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, ((PyObject *)__pyx_v_isymbols)); + __Pyx_INCREF(((PyObject *)__pyx_v_osymbols)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_osymbols)); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, ((PyObject *)__pyx_v_osymbols)); + __Pyx_INCREF(((PyObject *)__pyx_v_ssymbols)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_ssymbols)); + PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_7, ((PyObject *)__pyx_v_ssymbols)); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_8, 3+__pyx_t_7, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 4+__pyx_t_7, __pyx_t_4); + __Pyx_INCREF(__pyx_v_missing_sym); + __Pyx_GIVEREF(__pyx_v_missing_sym); + PyTuple_SET_ITEM(__pyx_t_8, 5+__pyx_t_7, __pyx_v_missing_sym); + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1678, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_9 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1678, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_9; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1703 + * """ + * # Prints FST to stringstream, then returns resulting string. + * cdef fst.SymbolTable *ssymbols_ptr = NULL # <<<<<<<<<<<<<< + * if ssymbols is not None: + * ssymbols_ptr = ssymbols._table + */ + __pyx_v_ssymbols_ptr = NULL; + + /* "pywrapfst.pyx":1704 + * # Prints FST to stringstream, then returns resulting string. + * cdef fst.SymbolTable *ssymbols_ptr = NULL + * if ssymbols is not None: # <<<<<<<<<<<<<< + * ssymbols_ptr = ssymbols._table + * cdef stringstream sstrm + */ + __pyx_t_10 = (((PyObject *)__pyx_v_ssymbols) != Py_None); + __pyx_t_11 = (__pyx_t_10 != 0); + if (__pyx_t_11) { + + /* "pywrapfst.pyx":1705 + * cdef fst.SymbolTable *ssymbols_ptr = NULL + * if ssymbols is not None: + * ssymbols_ptr = ssymbols._table # <<<<<<<<<<<<<< + * cdef stringstream sstrm + * fst.PrintFst(deref(self._fst), sstrm, b"", + */ + if (unlikely(((PyObject *)__pyx_v_ssymbols) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 1705, __pyx_L1_error) + } + __pyx_t_12 = __pyx_v_ssymbols->_table; + __pyx_v_ssymbols_ptr = __pyx_t_12; + + /* "pywrapfst.pyx":1704 + * # Prints FST to stringstream, then returns resulting string. + * cdef fst.SymbolTable *ssymbols_ptr = NULL + * if ssymbols is not None: # <<<<<<<<<<<<<< + * ssymbols_ptr = ssymbols._table + * cdef stringstream sstrm + */ + } + + /* "pywrapfst.pyx":1707 + * ssymbols_ptr = ssymbols._table + * cdef stringstream sstrm + * fst.PrintFst(deref(self._fst), sstrm, b"", # <<<<<<<<<<<<<< + * self._fst.get().InputSymbols() if isymbols is None + * else isymbols._table, + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1707, __pyx_L1_error) + } + __pyx_t_9 = __pyx_convert_string_from_py_std__in_string(__pyx_kp_b_pywrapfst); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1707, __pyx_L1_error) + + /* "pywrapfst.pyx":1708 + * cdef stringstream sstrm + * fst.PrintFst(deref(self._fst), sstrm, b"", + * self._fst.get().InputSymbols() if isymbols is None # <<<<<<<<<<<<<< + * else isymbols._table, + * self._fst.get().OutputSymbols() if osymbols is None + */ + __pyx_t_11 = (((PyObject *)__pyx_v_isymbols) == Py_None); + if ((__pyx_t_11 != 0)) { + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1708, __pyx_L1_error) + } + __pyx_t_13 = __pyx_v_self->_fst.get()->InputSymbols(); + } else { + + /* "pywrapfst.pyx":1709 + * fst.PrintFst(deref(self._fst), sstrm, b"", + * self._fst.get().InputSymbols() if isymbols is None + * else isymbols._table, # <<<<<<<<<<<<<< + * self._fst.get().OutputSymbols() if osymbols is None + * else osymbols._table, + */ + if (unlikely(((PyObject *)__pyx_v_isymbols) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 1709, __pyx_L1_error) + } + __pyx_t_13 = __pyx_v_isymbols->_table; + } + + /* "pywrapfst.pyx":1710 + * self._fst.get().InputSymbols() if isymbols is None + * else isymbols._table, + * self._fst.get().OutputSymbols() if osymbols is None # <<<<<<<<<<<<<< + * else osymbols._table, + * ssymbols_ptr, acceptor, show_weight_one, tostring(missing_sym)) + */ + __pyx_t_11 = (((PyObject *)__pyx_v_osymbols) == Py_None); + if ((__pyx_t_11 != 0)) { + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1710, __pyx_L1_error) + } + __pyx_t_14 = __pyx_v_self->_fst.get()->OutputSymbols(); + } else { + + /* "pywrapfst.pyx":1711 + * else isymbols._table, + * self._fst.get().OutputSymbols() if osymbols is None + * else osymbols._table, # <<<<<<<<<<<<<< + * ssymbols_ptr, acceptor, show_weight_one, tostring(missing_sym)) + * return sstrm.str() + */ + if (unlikely(((PyObject *)__pyx_v_osymbols) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 1711, __pyx_L1_error) + } + __pyx_t_14 = __pyx_v_osymbols->_table; + } + + /* "pywrapfst.pyx":1712 + * self._fst.get().OutputSymbols() if osymbols is None + * else osymbols._table, + * ssymbols_ptr, acceptor, show_weight_one, tostring(missing_sym)) # <<<<<<<<<<<<<< + * return sstrm.str() + * + */ + __pyx_t_15 = __pyx_f_9pywrapfst_tostring(__pyx_v_missing_sym, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1712, __pyx_L1_error) + + /* "pywrapfst.pyx":1707 + * ssymbols_ptr = ssymbols._table + * cdef stringstream sstrm + * fst.PrintFst(deref(self._fst), sstrm, b"", # <<<<<<<<<<<<<< + * self._fst.get().InputSymbols() if isymbols is None + * else isymbols._table, + */ + fst::script::PrintFst((*__pyx_v_self->_fst), __pyx_v_sstrm, __pyx_t_9, __pyx_t_13, __pyx_t_14, __pyx_v_ssymbols_ptr, __pyx_v_acceptor, __pyx_v_show_weight_one, __pyx_t_15); + + /* "pywrapfst.pyx":1713 + * else osymbols._table, + * ssymbols_ptr, acceptor, show_weight_one, tostring(missing_sym)) + * return sstrm.str() # <<<<<<<<<<<<<< + * + * cpdef bool verify(self): + */ + __pyx_r = __pyx_v_sstrm.str(); + goto __pyx_L0; + + /* "pywrapfst.pyx":1678 + * return StateIterator(self) + * + * cpdef string text(self, _SymbolTable isymbols=None, # <<<<<<<<<<<<<< + * _SymbolTable osymbols=None, _SymbolTable ssymbols=None, + * bool acceptor=False, bool show_weight_one=False, missing_sym=b""): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_WriteUnraisable("pywrapfst._Fst.text", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_39text(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_4_Fst_38text[] = "\n text(self, isymbols=None, osymbols=None, ssymbols=None, acceptor=False,\n show_weight_one=False, missing_sym=\"\")\n\n Produces a human-readable string representation of the FST.\n\n This method generates a human-readable string representation of the FST.\n The caller may optionally specify SymbolTables used to label input labels,\n output labels, or state labels, respectively.\n\n Args:\n isymbols: An optional symbol table used to label input symbols.\n osymbols: An optional symbol table used to label output symbols.\n ssymbols: An optional symbol table used to label states.\n acceptor: Should the FST be rendered in acceptor format if possible?\n show_weight_one: Should weights equivalent to semiring One be printed?\n missing_symbol: The string to be printed when symbol table lookup fails.\n\n Returns:\n A formatted string representing the machine.\n "; +static PyObject *__pyx_pw_9pywrapfst_4_Fst_39text(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_isymbols = 0; + struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_osymbols = 0; + struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_ssymbols = 0; + bool __pyx_v_acceptor; + bool __pyx_v_show_weight_one; + PyObject *__pyx_v_missing_sym = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("text (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_isymbols,&__pyx_n_s_osymbols,&__pyx_n_s_ssymbols,&__pyx_n_s_acceptor,&__pyx_n_s_show_weight_one,&__pyx_n_s_missing_sym,0}; + PyObject* values[6] = {0,0,0,0,0,0}; + values[0] = (PyObject *)((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None); + + /* "pywrapfst.pyx":1679 + * + * cpdef string text(self, _SymbolTable isymbols=None, + * _SymbolTable osymbols=None, _SymbolTable ssymbols=None, # <<<<<<<<<<<<<< + * bool acceptor=False, bool show_weight_one=False, missing_sym=b""): + * """ + */ + values[1] = (PyObject *)((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None); + values[2] = (PyObject *)((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None); + values[5] = ((PyObject *)__pyx_kp_b__24); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_isymbols); + if (value) { values[0] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_osymbols); + if (value) { values[1] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ssymbols); + if (value) { values[2] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_acceptor); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_show_weight_one); + if (value) { values[4] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_missing_sym); + if (value) { values[5] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "text") < 0)) __PYX_ERR(0, 1678, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_isymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[0]); + __pyx_v_osymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[1]); + __pyx_v_ssymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[2]); + if (values[3]) { + __pyx_v_acceptor = __Pyx_PyObject_IsTrue(values[3]); if (unlikely((__pyx_v_acceptor == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1680, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":1680 + * cpdef string text(self, _SymbolTable isymbols=None, + * _SymbolTable osymbols=None, _SymbolTable ssymbols=None, + * bool acceptor=False, bool show_weight_one=False, missing_sym=b""): # <<<<<<<<<<<<<< + * """ + * text(self, isymbols=None, osymbols=None, ssymbols=None, acceptor=False, + */ + __pyx_v_acceptor = ((bool)0); + } + if (values[4]) { + __pyx_v_show_weight_one = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_show_weight_one == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1680, __pyx_L3_error) + } else { + __pyx_v_show_weight_one = ((bool)0); + } + __pyx_v_missing_sym = values[5]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("text", 0, 0, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1678, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._Fst.text", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_isymbols), __pyx_ptype_9pywrapfst__SymbolTable, 1, "isymbols", 0))) __PYX_ERR(0, 1678, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_osymbols), __pyx_ptype_9pywrapfst__SymbolTable, 1, "osymbols", 0))) __PYX_ERR(0, 1679, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ssymbols), __pyx_ptype_9pywrapfst__SymbolTable, 1, "ssymbols", 0))) __PYX_ERR(0, 1679, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_4_Fst_38text(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), __pyx_v_isymbols, __pyx_v_osymbols, __pyx_v_ssymbols, __pyx_v_acceptor, __pyx_v_show_weight_one, __pyx_v_missing_sym); + + /* "pywrapfst.pyx":1678 + * return StateIterator(self) + * + * cpdef string text(self, _SymbolTable isymbols=None, # <<<<<<<<<<<<<< + * _SymbolTable osymbols=None, _SymbolTable ssymbols=None, + * bool acceptor=False, bool show_weight_one=False, missing_sym=b""): + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4_Fst_38text(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_isymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_osymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_ssymbols, bool __pyx_v_acceptor, bool __pyx_v_show_weight_one, PyObject *__pyx_v_missing_sym) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + std::string __pyx_t_1; + struct __pyx_opt_args_9pywrapfst_4_Fst_text __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("text", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 6; + __pyx_t_2.isymbols = __pyx_v_isymbols; + __pyx_t_2.osymbols = __pyx_v_osymbols; + __pyx_t_2.ssymbols = __pyx_v_ssymbols; + __pyx_t_2.acceptor = __pyx_v_acceptor; + __pyx_t_2.show_weight_one = __pyx_v_show_weight_one; + __pyx_t_2.missing_sym = __pyx_v_missing_sym; + __pyx_t_1 = __pyx_vtabptr_9pywrapfst__Fst->text(__pyx_v_self, 1, &__pyx_t_2); + __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1678, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pywrapfst._Fst.text", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1715 + * return sstrm.str() + * + * cpdef bool verify(self): # <<<<<<<<<<<<<< + * """ + * verify(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_4_Fst_41verify(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static bool __pyx_f_9pywrapfst_4_Fst_verify(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch) { + bool __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + bool __pyx_t_5; + __Pyx_RefNannySetupContext("verify", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_verify); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1715, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_41verify)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1715, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1715, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1715, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1724 + * True if the contents are sane, False otherwise. + * """ + * return fst.Verify(deref(self._fst)) # <<<<<<<<<<<<<< + * + * cpdef string weight_type(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1724, __pyx_L1_error) + } + __pyx_r = fst::script::Verify((*__pyx_v_self->_fst)); + goto __pyx_L0; + + /* "pywrapfst.pyx":1715 + * return sstrm.str() + * + * cpdef bool verify(self): # <<<<<<<<<<<<<< + * """ + * verify(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst._Fst.verify", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_41verify(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_4_Fst_40verify[] = "\n verify(self)\n\n Verifies that an FST's contents are sane.\n\n Returns:\n True if the contents are sane, False otherwise.\n "; +static PyObject *__pyx_pw_9pywrapfst_4_Fst_41verify(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("verify (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_4_Fst_40verify(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4_Fst_40verify(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("verify", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_9pywrapfst_4_Fst_verify(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1715, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._Fst.verify", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1726 + * return fst.Verify(deref(self._fst)) + * + * cpdef string weight_type(self): # <<<<<<<<<<<<<< + * """ + * weight_type(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_4_Fst_43weight_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static std::string __pyx_f_9pywrapfst_4_Fst_weight_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch) { + std::string __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + std::string __pyx_t_5; + __Pyx_RefNannySetupContext("weight_type", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_weight_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1726, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_43weight_type)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1726, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1726, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1726, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1735 + * A string representing the weight type. + * """ + * return self._fst.get().WeightType() # <<<<<<<<<<<<<< + * + * cpdef void write(self, filename) except *: + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1735, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_fst.get()->WeightType(); + goto __pyx_L0; + + /* "pywrapfst.pyx":1726 + * return fst.Verify(deref(self._fst)) + * + * cpdef string weight_type(self): # <<<<<<<<<<<<<< + * """ + * weight_type(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst._Fst.weight_type", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_43weight_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_4_Fst_42weight_type[] = "\n weight_type(self)\n\n Provides the FST's weight type.\n\n Returns:\n A string representing the weight type.\n "; +static PyObject *__pyx_pw_9pywrapfst_4_Fst_43weight_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("weight_type (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_4_Fst_42weight_type(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4_Fst_42weight_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("weight_type", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_4_Fst_weight_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1726, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._Fst.weight_type", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1737 + * return self._fst.get().WeightType() + * + * cpdef void write(self, filename) except *: # <<<<<<<<<<<<<< + * """ + * write(self, filename) + */ + +static PyObject *__pyx_pw_9pywrapfst_4_Fst_45write(PyObject *__pyx_v_self, PyObject *__pyx_v_filename); /*proto*/ +static void __pyx_f_9pywrapfst_4_Fst_write(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, PyObject *__pyx_v_filename, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + std::string __pyx_t_6; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("write", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_write); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1737, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_45write)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_filename); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1737, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1737, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1737, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1737, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_filename); + __Pyx_GIVEREF(__pyx_v_filename); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_filename); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1737, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1751 + * FstIOError: Write failed. + * """ + * if not self._fst.get().Write(tostring(filename)): # <<<<<<<<<<<<<< + * raise FstIOError("Write failed: {!r}".format(filename)) + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1751, __pyx_L1_error) + } + __pyx_t_6 = __pyx_f_9pywrapfst_tostring(__pyx_v_filename, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1751, __pyx_L1_error) + __pyx_t_7 = ((!(__pyx_v_self->_fst.get()->Write(__pyx_t_6) != 0)) != 0); + if (__pyx_t_7) { + + /* "pywrapfst.pyx":1752 + * """ + * if not self._fst.get().Write(tostring(filename)): + * raise FstIOError("Write failed: {!r}".format(filename)) # <<<<<<<<<<<<<< + * + * cpdef string write_to_string(self): + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIOError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1752, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Write_failed_r, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1752, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_4) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_filename); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1752, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1752, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1752, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1752, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_filename); + __Pyx_GIVEREF(__pyx_v_filename); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_filename); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1752, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_5) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1752, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1752, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1752, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1752, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1752, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 1752, __pyx_L1_error) + + /* "pywrapfst.pyx":1751 + * FstIOError: Write failed. + * """ + * if not self._fst.get().Write(tostring(filename)): # <<<<<<<<<<<<<< + * raise FstIOError("Write failed: {!r}".format(filename)) + * + */ + } + + /* "pywrapfst.pyx":1737 + * return self._fst.get().WeightType() + * + * cpdef void write(self, filename) except *: # <<<<<<<<<<<<<< + * """ + * write(self, filename) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pywrapfst._Fst.write", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_45write(PyObject *__pyx_v_self, PyObject *__pyx_v_filename); /*proto*/ +static char __pyx_doc_9pywrapfst_4_Fst_44write[] = "\n write(self, filename)\n\n Serializes FST to a file.\n\n This method writes the FST to a file in a binary format.\n\n Args:\n filename: The string location of the output file.\n\n Raises:\n FstIOError: Write failed.\n "; +static PyObject *__pyx_pw_9pywrapfst_4_Fst_45write(PyObject *__pyx_v_self, PyObject *__pyx_v_filename) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("write (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_4_Fst_44write(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), ((PyObject *)__pyx_v_filename)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4_Fst_44write(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, PyObject *__pyx_v_filename) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("write", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_f_9pywrapfst_4_Fst_write(__pyx_v_self, __pyx_v_filename, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1737, __pyx_L1_error) + __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1737, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._Fst.write", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1754 + * raise FstIOError("Write failed: {!r}".format(filename)) + * + * cpdef string write_to_string(self): # <<<<<<<<<<<<<< + * """ + * write_to_string(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_4_Fst_47write_to_string(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static std::string __pyx_f_9pywrapfst_4_Fst_write_to_string(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch) { + std::stringstream __pyx_v_sstrm; + std::string __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + std::string __pyx_t_5; + int __pyx_t_6; + __Pyx_RefNannySetupContext("write_to_string", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_write_to_string); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1754, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_47write_to_string)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1754, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1754, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1754, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1769 + * """ + * cdef stringstream sstrm + * if not self._fst.get().Write(sstrm, "write_to_string"): # <<<<<<<<<<<<<< + * raise FstIOError("Write to string failed") + * return sstrm.str() + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1769, __pyx_L1_error) + } + __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_n_b_write_to_string); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1769, __pyx_L1_error) + __pyx_t_6 = ((!(__pyx_v_self->_fst.get()->Write(__pyx_v_sstrm, __pyx_t_5) != 0)) != 0); + if (__pyx_t_6) { + + /* "pywrapfst.pyx":1770 + * cdef stringstream sstrm + * if not self._fst.get().Write(sstrm, "write_to_string"): + * raise FstIOError("Write to string failed") # <<<<<<<<<<<<<< + * return sstrm.str() + * + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIOError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1770, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1770, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1770, __pyx_L1_error) + + /* "pywrapfst.pyx":1769 + * """ + * cdef stringstream sstrm + * if not self._fst.get().Write(sstrm, "write_to_string"): # <<<<<<<<<<<<<< + * raise FstIOError("Write to string failed") + * return sstrm.str() + */ + } + + /* "pywrapfst.pyx":1771 + * if not self._fst.get().Write(sstrm, "write_to_string"): + * raise FstIOError("Write to string failed") + * return sstrm.str() # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_sstrm.str(); + goto __pyx_L0; + + /* "pywrapfst.pyx":1754 + * raise FstIOError("Write failed: {!r}".format(filename)) + * + * cpdef string write_to_string(self): # <<<<<<<<<<<<<< + * """ + * write_to_string(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst._Fst.write_to_string", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_4_Fst_47write_to_string(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_4_Fst_46write_to_string[] = "\n write_to_string(self)\n\n Serializes FST to a string.\n\n Returns:\n A string.\n\n Raises:\n FstIOError: Write to string failed.\n\n See also: `read_from_string`.\n "; +static PyObject *__pyx_pw_9pywrapfst_4_Fst_47write_to_string(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("write_to_string (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_4_Fst_46write_to_string(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_4_Fst_46write_to_string(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("write_to_string", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_4_Fst_write_to_string(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1754, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._Fst.write_to_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1784 + * """ + * + * cdef void _check_mutating_imethod(self) except *: # <<<<<<<<<<<<<< + * """Checks whether an operation mutating the FST has produced an error. + * + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__check_mutating_imethod(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("_check_mutating_imethod", 0); + + /* "pywrapfst.pyx":1789 + * This function is not visible to Python users. + * """ + * if self._fst.get().Properties(fst.kError, True) == fst.kError: # <<<<<<<<<<<<<< + * raise FstOpError("Operation failed") + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1789, __pyx_L1_error) + } + __pyx_t_1 = ((__pyx_v_self->__pyx_base._fst.get()->Properties(fst::kError, 1) == fst::kError) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":1790 + * """ + * if self._fst.get().Properties(fst.kError, True) == fst.kError: + * raise FstOpError("Operation failed") # <<<<<<<<<<<<<< + * + * cdef void _add_arc(self, int64 state, Arc arc) except *: + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1790, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__30, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1790, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 1790, __pyx_L1_error) + + /* "pywrapfst.pyx":1789 + * This function is not visible to Python users. + * """ + * if self._fst.get().Properties(fst.kError, True) == fst.kError: # <<<<<<<<<<<<<< + * raise FstOpError("Operation failed") + * + */ + } + + /* "pywrapfst.pyx":1784 + * """ + * + * cdef void _check_mutating_imethod(self) except *: # <<<<<<<<<<<<<< + * """Checks whether an operation mutating the FST has produced an error. + * + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pywrapfst._MutableFst._check_mutating_imethod", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":1792 + * raise FstOpError("Operation failed") + * + * cdef void _add_arc(self, int64 state, Arc arc) except *: # <<<<<<<<<<<<<< + * if not self._fst.get().ValidStateId(state): + * raise FstIndexError("State index out of range") + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__add_arc(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("_add_arc", 0); + + /* "pywrapfst.pyx":1793 + * + * cdef void _add_arc(self, int64 state, Arc arc) except *: + * if not self._fst.get().ValidStateId(state): # <<<<<<<<<<<<<< + * raise FstIndexError("State index out of range") + * if not self._mfst.get().AddArc(state, deref(arc._arc)): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1793, __pyx_L1_error) + } + __pyx_t_1 = ((!(__pyx_v_self->__pyx_base._fst.get()->ValidStateId(__pyx_v_state) != 0)) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":1794 + * cdef void _add_arc(self, int64 state, Arc arc) except *: + * if not self._fst.get().ValidStateId(state): + * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< + * if not self._mfst.get().AddArc(state, deref(arc._arc)): + * raise FstOpError("Incompatible or invalid weight type") + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1794, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1794, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 1794, __pyx_L1_error) + + /* "pywrapfst.pyx":1793 + * + * cdef void _add_arc(self, int64 state, Arc arc) except *: + * if not self._fst.get().ValidStateId(state): # <<<<<<<<<<<<<< + * raise FstIndexError("State index out of range") + * if not self._mfst.get().AddArc(state, deref(arc._arc)): + */ + } + + /* "pywrapfst.pyx":1795 + * if not self._fst.get().ValidStateId(state): + * raise FstIndexError("State index out of range") + * if not self._mfst.get().AddArc(state, deref(arc._arc)): # <<<<<<<<<<<<<< + * raise FstOpError("Incompatible or invalid weight type") + * self._check_mutating_imethod() + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 1795, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_arc) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_arc"); + __PYX_ERR(0, 1795, __pyx_L1_error) + } + __pyx_t_1 = ((!(__pyx_v_self->_mfst.get()->AddArc(__pyx_v_state, (*__pyx_v_arc->_arc)) != 0)) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":1796 + * raise FstIndexError("State index out of range") + * if not self._mfst.get().AddArc(state, deref(arc._arc)): + * raise FstOpError("Incompatible or invalid weight type") # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1796, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__32, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1796, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1796, __pyx_L1_error) + + /* "pywrapfst.pyx":1795 + * if not self._fst.get().ValidStateId(state): + * raise FstIndexError("State index out of range") + * if not self._mfst.get().AddArc(state, deref(arc._arc)): # <<<<<<<<<<<<<< + * raise FstOpError("Incompatible or invalid weight type") + * self._check_mutating_imethod() + */ + } + + /* "pywrapfst.pyx":1797 + * if not self._mfst.get().AddArc(state, deref(arc._arc)): + * raise FstOpError("Incompatible or invalid weight type") + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def add_arc(self, int64 state, Arc arc): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 1797, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1797, __pyx_L1_error) + + /* "pywrapfst.pyx":1792 + * raise FstOpError("Operation failed") + * + * cdef void _add_arc(self, int64 state, Arc arc) except *: # <<<<<<<<<<<<<< + * if not self._fst.get().ValidStateId(state): + * raise FstIndexError("State index out of range") + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pywrapfst._MutableFst._add_arc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":1799 + * self._check_mutating_imethod() + * + * def add_arc(self, int64 state, Arc arc): # <<<<<<<<<<<<<< + * """ + * add_arc(self, state, arc) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_1add_arc(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_add_arc[] = "\n add_arc(self, state, arc)\n\n Adds a new arc to the FST and return self.\n\n Args:\n state: The integer index of the source state.\n arc: The arc to add.\n\n Returns:\n self.\n\n Raises:\n FstIndexError: State index out of range.\n FstOpdexError: Incompatible or invalid weight type.\n\n See also: `add_state`.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_1add_arc(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + __pyx_t_10basictypes_int64 __pyx_v_state; + struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("add_arc (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_state,&__pyx_n_s_arc,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_arc)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("add_arc", 1, 2, 2, 1); __PYX_ERR(0, 1799, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "add_arc") < 0)) __PYX_ERR(0, 1799, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_state = __Pyx_PyInt_As_int64_t(values[0]); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1799, __pyx_L3_error) + __pyx_v_arc = ((struct __pyx_obj_9pywrapfst_Arc *)values[1]); + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("add_arc", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1799, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.add_arc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_arc), __pyx_ptype_9pywrapfst_Arc, 1, "arc", 0))) __PYX_ERR(0, 1799, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_add_arc(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_state, __pyx_v_arc); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_add_arc(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("add_arc", 0); + + /* "pywrapfst.pyx":1818 + * See also: `add_state`. + * """ + * self._add_arc(state, arc) # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_add_arc"); + __PYX_ERR(0, 1818, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_add_arc(__pyx_v_self, __pyx_v_state, __pyx_v_arc); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1818, __pyx_L1_error) + + /* "pywrapfst.pyx":1819 + * """ + * self._add_arc(state, arc) + * return self # <<<<<<<<<<<<<< + * + * cpdef int64 add_state(self) except *: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":1799 + * self._check_mutating_imethod() + * + * def add_arc(self, int64 state, Arc arc): # <<<<<<<<<<<<<< + * """ + * add_arc(self, state, arc) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.add_arc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1821 + * return self + * + * cpdef int64 add_state(self) except *: # <<<<<<<<<<<<<< + * """ + * add_state(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_3add_state(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_11_MutableFst_add_state(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, int __pyx_skip_dispatch) { + __pyx_t_10basictypes_int64 __pyx_v_result; + __pyx_t_10basictypes_int64 __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __pyx_t_10basictypes_int64 __pyx_t_5; + __Pyx_RefNannySetupContext("add_state", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1821, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_3add_state)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1821, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1821, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1821, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":1832 + * See also: `add_arc`, `set_start`, `set_final`. + * """ + * cdef int64 result = self._mfst.get().AddState() # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * return result + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 1832, __pyx_L1_error) + } + __pyx_v_result = __pyx_v_self->_mfst.get()->AddState(); + + /* "pywrapfst.pyx":1833 + * """ + * cdef int64 result = self._mfst.get().AddState() + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * return result + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 1833, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1833, __pyx_L1_error) + + /* "pywrapfst.pyx":1834 + * cdef int64 result = self._mfst.get().AddState() + * self._check_mutating_imethod() + * return result # <<<<<<<<<<<<<< + * + * cdef void _arcsort(self, sort_type=b"ilabel") except *: + */ + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "pywrapfst.pyx":1821 + * return self + * + * cpdef int64 add_state(self) except *: # <<<<<<<<<<<<<< + * """ + * add_state(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pywrapfst._MutableFst.add_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_3add_state(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_2add_state[] = "\n add_state(self)\n\n Adds a new state to the FST and returns the state ID.\n\n Returns:\n The integer index of the new state.\n\n See also: `add_arc`, `set_start`, `set_final`.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_3add_state(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("add_state (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_2add_state(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_2add_state(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __pyx_t_10basictypes_int64 __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("add_state", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pywrapfst_11_MutableFst_add_state(__pyx_v_self, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1821, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_int64_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1821, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pywrapfst._MutableFst.add_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1836 + * return result + * + * cdef void _arcsort(self, sort_type=b"ilabel") except *: # <<<<<<<<<<<<<< + * cdef fst.ArcSortType sort_type_enum + * if not fst.GetArcSortType(tostring(sort_type), addr(sort_type_enum)): + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__arcsort(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__arcsort *__pyx_optional_args) { + PyObject *__pyx_v_sort_type = ((PyObject *)__pyx_n_b_ilabel); + enum fst::script::ArcSortType __pyx_v_sort_type_enum; + __Pyx_RefNannyDeclarations + std::string __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("_arcsort", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_sort_type = __pyx_optional_args->sort_type; + } + } + + /* "pywrapfst.pyx":1838 + * cdef void _arcsort(self, sort_type=b"ilabel") except *: + * cdef fst.ArcSortType sort_type_enum + * if not fst.GetArcSortType(tostring(sort_type), addr(sort_type_enum)): # <<<<<<<<<<<<<< + * raise FstArgError("Unknown sort type {!r}".format(sort_type)) + * fst.ArcSort(self._mfst.get(), sort_type_enum) + */ + __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_sort_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1838, __pyx_L1_error) + __pyx_t_2 = ((!(fst::script::GetArcSortType(__pyx_t_1, (&__pyx_v_sort_type_enum)) != 0)) != 0); + if (__pyx_t_2) { + + /* "pywrapfst.pyx":1839 + * cdef fst.ArcSortType sort_type_enum + * if not fst.GetArcSortType(tostring(sort_type), addr(sort_type_enum)): + * raise FstArgError("Unknown sort type {!r}".format(sort_type)) # <<<<<<<<<<<<<< + * fst.ArcSort(self._mfst.get(), sort_type_enum) + * self._check_mutating_imethod() + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1839, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Unknown_sort_type_r, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1839, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + if (!__pyx_t_7) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_sort_type); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1839, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_sort_type}; + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1839, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_sort_type}; + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1839, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1839, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_INCREF(__pyx_v_sort_type); + __Pyx_GIVEREF(__pyx_v_sort_type); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_sort_type); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1839, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_6) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1839, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1839, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1839, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1839, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1839, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 1839, __pyx_L1_error) + + /* "pywrapfst.pyx":1838 + * cdef void _arcsort(self, sort_type=b"ilabel") except *: + * cdef fst.ArcSortType sort_type_enum + * if not fst.GetArcSortType(tostring(sort_type), addr(sort_type_enum)): # <<<<<<<<<<<<<< + * raise FstArgError("Unknown sort type {!r}".format(sort_type)) + * fst.ArcSort(self._mfst.get(), sort_type_enum) + */ + } + + /* "pywrapfst.pyx":1840 + * if not fst.GetArcSortType(tostring(sort_type), addr(sort_type_enum)): + * raise FstArgError("Unknown sort type {!r}".format(sort_type)) + * fst.ArcSort(self._mfst.get(), sort_type_enum) # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 1840, __pyx_L1_error) + } + fst::script::ArcSort(__pyx_v_self->_mfst.get(), __pyx_v_sort_type_enum); + + /* "pywrapfst.pyx":1841 + * raise FstArgError("Unknown sort type {!r}".format(sort_type)) + * fst.ArcSort(self._mfst.get(), sort_type_enum) + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def arcsort(self, sort_type=b"ilabel"): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 1841, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1841, __pyx_L1_error) + + /* "pywrapfst.pyx":1836 + * return result + * + * cdef void _arcsort(self, sort_type=b"ilabel") except *: # <<<<<<<<<<<<<< + * cdef fst.ArcSortType sort_type_enum + * if not fst.GetArcSortType(tostring(sort_type), addr(sort_type_enum)): + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pywrapfst._MutableFst._arcsort", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":1843 + * self._check_mutating_imethod() + * + * def arcsort(self, sort_type=b"ilabel"): # <<<<<<<<<<<<<< + * """ + * arcsort(self, sort_type="ilabel") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_5arcsort(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_4arcsort[] = "\n arcsort(self, sort_type=\"ilabel\")\n\n Sorts arcs leaving each state of the FST.\n\n This operation destructively sorts arcs leaving each state using either\n input or output labels.\n\n Args:\n sort_type: Either \"ilabel\" (sort arcs according to input labels) or\n \"olabel\" (sort arcs according to output labels).\n\n Returns:\n self.\n\n Raises:\n FstArgError: Unknown sort type.\n\n See also: `topsort`.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_5arcsort(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_sort_type = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("arcsort (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sort_type,0}; + PyObject* values[1] = {0}; + values[0] = ((PyObject *)__pyx_n_b_ilabel); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_sort_type); + if (value) { values[0] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "arcsort") < 0)) __PYX_ERR(0, 1843, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_sort_type = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("arcsort", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1843, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.arcsort", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_4arcsort(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_sort_type); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_4arcsort(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, PyObject *__pyx_v_sort_type) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + struct __pyx_opt_args_9pywrapfst_11_MutableFst__arcsort __pyx_t_1; + __Pyx_RefNannySetupContext("arcsort", 0); + + /* "pywrapfst.pyx":1864 + * See also: `topsort`. + * """ + * self._arcsort(sort_type) # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_arcsort"); + __PYX_ERR(0, 1864, __pyx_L1_error) + } + __pyx_t_1.__pyx_n = 1; + __pyx_t_1.sort_type = __pyx_v_sort_type; + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_arcsort(__pyx_v_self, &__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1864, __pyx_L1_error) + + /* "pywrapfst.pyx":1865 + * """ + * self._arcsort(sort_type) + * return self # <<<<<<<<<<<<<< + * + * cdef void _closure(self, bool closure_plus=False) except *: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":1843 + * self._check_mutating_imethod() + * + * def arcsort(self, sort_type=b"ilabel"): # <<<<<<<<<<<<<< + * """ + * arcsort(self, sort_type="ilabel") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.arcsort", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1867 + * return self + * + * cdef void _closure(self, bool closure_plus=False) except *: # <<<<<<<<<<<<<< + * fst.Closure(self._mfst.get(), fst.GetClosureType(closure_plus)) + * self._check_mutating_imethod() + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__closure(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__closure *__pyx_optional_args) { + bool __pyx_v_closure_plus = ((bool)0); + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_closure", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_closure_plus = __pyx_optional_args->closure_plus; + } + } + + /* "pywrapfst.pyx":1868 + * + * cdef void _closure(self, bool closure_plus=False) except *: + * fst.Closure(self._mfst.get(), fst.GetClosureType(closure_plus)) # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 1868, __pyx_L1_error) + } + fst::script::Closure(__pyx_v_self->_mfst.get(), fst::script::GetClosureType(__pyx_v_closure_plus)); + + /* "pywrapfst.pyx":1869 + * cdef void _closure(self, bool closure_plus=False) except *: + * fst.Closure(self._mfst.get(), fst.GetClosureType(closure_plus)) + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def closure(self, bool closure_plus=False): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 1869, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1869, __pyx_L1_error) + + /* "pywrapfst.pyx":1867 + * return self + * + * cdef void _closure(self, bool closure_plus=False) except *: # <<<<<<<<<<<<<< + * fst.Closure(self._mfst.get(), fst.GetClosureType(closure_plus)) + * self._check_mutating_imethod() + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst._closure", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":1871 + * self._check_mutating_imethod() + * + * def closure(self, bool closure_plus=False): # <<<<<<<<<<<<<< + * """ + * closure(self, closure_plus=False) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_7closure(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_6closure[] = "\n closure(self, closure_plus=False)\n\n Computes concatenative closure.\n\n This operation destructively converts the FST to its concatenative closure.\n If A transduces string x to y with weight a, then the closure transduces x\n to y with weight a, xx to yy with weight a \\otimes a, xxx to yyy with weight\n a \\otimes a \\otimes a, and so on. The empty string is also transduced to\n itself with semiring One if `closure_plus` is False.\n\n Args:\n closure_plus: If False, do not accept the empty string.\n\n Returns:\n self.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_7closure(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + bool __pyx_v_closure_plus; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("closure (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_closure_plus,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_closure_plus); + if (value) { values[0] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "closure") < 0)) __PYX_ERR(0, 1871, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + if (values[0]) { + __pyx_v_closure_plus = __Pyx_PyObject_IsTrue(values[0]); if (unlikely((__pyx_v_closure_plus == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1871, __pyx_L3_error) + } else { + __pyx_v_closure_plus = ((bool)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("closure", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1871, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.closure", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_6closure(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_closure_plus); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_6closure(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, bool __pyx_v_closure_plus) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + struct __pyx_opt_args_9pywrapfst_11_MutableFst__closure __pyx_t_1; + __Pyx_RefNannySetupContext("closure", 0); + + /* "pywrapfst.pyx":1889 + * self. + * """ + * self._closure(closure_plus) # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_closure"); + __PYX_ERR(0, 1889, __pyx_L1_error) + } + __pyx_t_1.__pyx_n = 1; + __pyx_t_1.closure_plus = __pyx_v_closure_plus; + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_closure(__pyx_v_self, &__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1889, __pyx_L1_error) + + /* "pywrapfst.pyx":1890 + * """ + * self._closure(closure_plus) + * return self # <<<<<<<<<<<<<< + * + * cdef void _concat(self, _Fst ifst) except *: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":1871 + * self._check_mutating_imethod() + * + * def closure(self, bool closure_plus=False): # <<<<<<<<<<<<<< + * """ + * closure(self, closure_plus=False) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.closure", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1892 + * return self + * + * cdef void _concat(self, _Fst ifst) except *: # <<<<<<<<<<<<<< + * fst.Concat(self._mfst.get(), deref(ifst._fst)) + * self._check_mutating_imethod() + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__concat(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_concat", 0); + + /* "pywrapfst.pyx":1893 + * + * cdef void _concat(self, _Fst ifst) except *: + * fst.Concat(self._mfst.get(), deref(ifst._fst)) # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 1893, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 1893, __pyx_L1_error) + } + fst::script::Concat(__pyx_v_self->_mfst.get(), (*__pyx_v_ifst->_fst)); + + /* "pywrapfst.pyx":1894 + * cdef void _concat(self, _Fst ifst) except *: + * fst.Concat(self._mfst.get(), deref(ifst._fst)) + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def concat(self, _Fst ifst): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 1894, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1894, __pyx_L1_error) + + /* "pywrapfst.pyx":1892 + * return self + * + * cdef void _concat(self, _Fst ifst) except *: # <<<<<<<<<<<<<< + * fst.Concat(self._mfst.get(), deref(ifst._fst)) + * self._check_mutating_imethod() + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst._concat", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":1896 + * self._check_mutating_imethod() + * + * def concat(self, _Fst ifst): # <<<<<<<<<<<<<< + * """ + * concat(self, ifst) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_9concat(PyObject *__pyx_v_self, PyObject *__pyx_v_ifst); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_8concat[] = "\n concat(self, ifst)\n\n Computes the concatenation (product) of two FSTs.\n\n This operation destructively concatenates the FST with a second FST. If A\n transduces string x to y with weight a and B transduces string w to v with\n weight b, then their concatenation transduces string xw to yv with weight a\n \\otimes b.\n\n Args:\n ifst: The second input FST.\n\n Returns:\n self.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_9concat(PyObject *__pyx_v_self, PyObject *__pyx_v_ifst) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("concat (wrapper)", 0); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst), __pyx_ptype_9pywrapfst__Fst, 1, "ifst", 0))) __PYX_ERR(0, 1896, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_8concat(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_ifst)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_8concat(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("concat", 0); + + /* "pywrapfst.pyx":1913 + * self. + * """ + * self._concat(ifst) # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_concat"); + __PYX_ERR(0, 1913, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_concat(__pyx_v_self, __pyx_v_ifst); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1913, __pyx_L1_error) + + /* "pywrapfst.pyx":1914 + * """ + * self._concat(ifst) + * return self # <<<<<<<<<<<<<< + * + * cdef void _connect(self) except *: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":1896 + * self._check_mutating_imethod() + * + * def concat(self, _Fst ifst): # <<<<<<<<<<<<<< + * """ + * concat(self, ifst) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.concat", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1916 + * return self + * + * cdef void _connect(self) except *: # <<<<<<<<<<<<<< + * fst.Connect(self._mfst.get()) + * self._check_mutating_imethod() + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__connect(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_connect", 0); + + /* "pywrapfst.pyx":1917 + * + * cdef void _connect(self) except *: + * fst.Connect(self._mfst.get()) # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 1917, __pyx_L1_error) + } + fst::script::Connect(__pyx_v_self->_mfst.get()); + + /* "pywrapfst.pyx":1918 + * cdef void _connect(self) except *: + * fst.Connect(self._mfst.get()) + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def connect(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 1918, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1918, __pyx_L1_error) + + /* "pywrapfst.pyx":1916 + * return self + * + * cdef void _connect(self) except *: # <<<<<<<<<<<<<< + * fst.Connect(self._mfst.get()) + * self._check_mutating_imethod() + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst._connect", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":1920 + * self._check_mutating_imethod() + * + * def connect(self): # <<<<<<<<<<<<<< + * """ + * connect(self) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_11connect(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_10connect[] = "\n connect(self)\n\n Removes unsuccessful paths.\n\n This operation destructively trims the FST, removing states and arcs that\n are not part of any successful path.\n\n Returns:\n self.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_11connect(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("connect (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_10connect(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_10connect(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("connect", 0); + + /* "pywrapfst.pyx":1932 + * self. + * """ + * self._connect() # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_connect"); + __PYX_ERR(0, 1932, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_connect(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1932, __pyx_L1_error) + + /* "pywrapfst.pyx":1933 + * """ + * self._connect() + * return self # <<<<<<<<<<<<<< + * + * cdef void _decode(self, EncodeMapper encoder) except *: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":1920 + * self._check_mutating_imethod() + * + * def connect(self): # <<<<<<<<<<<<<< + * """ + * connect(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.connect", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1935 + * return self + * + * cdef void _decode(self, EncodeMapper encoder) except *: # <<<<<<<<<<<<<< + * fst.Decode(self._mfst.get(), deref(encoder._encoder)) + * self._check_mutating_imethod() + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__decode(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_encoder) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_decode", 0); + + /* "pywrapfst.pyx":1936 + * + * cdef void _decode(self, EncodeMapper encoder) except *: + * fst.Decode(self._mfst.get(), deref(encoder._encoder)) # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 1936, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_encoder) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_encoder"); + __PYX_ERR(0, 1936, __pyx_L1_error) + } + fst::script::Decode(__pyx_v_self->_mfst.get(), (*__pyx_v_encoder->_encoder)); + + /* "pywrapfst.pyx":1937 + * cdef void _decode(self, EncodeMapper encoder) except *: + * fst.Decode(self._mfst.get(), deref(encoder._encoder)) + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def decode(self, EncodeMapper encoder): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 1937, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1937, __pyx_L1_error) + + /* "pywrapfst.pyx":1935 + * return self + * + * cdef void _decode(self, EncodeMapper encoder) except *: # <<<<<<<<<<<<<< + * fst.Decode(self._mfst.get(), deref(encoder._encoder)) + * self._check_mutating_imethod() + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst._decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":1939 + * self._check_mutating_imethod() + * + * def decode(self, EncodeMapper encoder): # <<<<<<<<<<<<<< + * """ + * decode(self, encoder) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_13decode(PyObject *__pyx_v_self, PyObject *__pyx_v_encoder); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_12decode[] = "\n decode(self, encoder)\n\n Decodes encoded labels and/or weights.\n\n This operation reverses the encoding performed by `encode`.\n\n Args:\n encoder: An EncodeMapper object used to encode the FST.\n\n Returns:\n self.\n\n See also: `encode`.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_13decode(PyObject *__pyx_v_self, PyObject *__pyx_v_encoder) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("decode (wrapper)", 0); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_encoder), __pyx_ptype_9pywrapfst_EncodeMapper, 1, "encoder", 0))) __PYX_ERR(0, 1939, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_12decode(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_encoder)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_12decode(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_encoder) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("decode", 0); + + /* "pywrapfst.pyx":1955 + * See also: `encode`. + * """ + * self._decode(encoder) # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_decode"); + __PYX_ERR(0, 1955, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_decode(__pyx_v_self, __pyx_v_encoder); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1955, __pyx_L1_error) + + /* "pywrapfst.pyx":1956 + * """ + * self._decode(encoder) + * return self # <<<<<<<<<<<<<< + * + * cdef void _delete_arcs(self, int64 state, size_t n=0) except *: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":1939 + * self._check_mutating_imethod() + * + * def decode(self, EncodeMapper encoder): # <<<<<<<<<<<<<< + * """ + * decode(self, encoder) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.decode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1958 + * return self + * + * cdef void _delete_arcs(self, int64 state, size_t n=0) except *: # <<<<<<<<<<<<<< + * if not (self._mfst.get().DeleteArcs(state, n) if n else + * self._mfst.get().DeleteArcs(state)): + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__delete_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_arcs *__pyx_optional_args) { + size_t __pyx_v_n = ((size_t)0); + __Pyx_RefNannyDeclarations + bool __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("_delete_arcs", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_n = __pyx_optional_args->n; + } + } + + /* "pywrapfst.pyx":1959 + * + * cdef void _delete_arcs(self, int64 state, size_t n=0) except *: + * if not (self._mfst.get().DeleteArcs(state, n) if n else # <<<<<<<<<<<<<< + * self._mfst.get().DeleteArcs(state)): + * raise FstIndexError("State index out of range") + */ + if ((__pyx_v_n != 0)) { + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 1959, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_self->_mfst.get()->DeleteArcs(__pyx_v_state, __pyx_v_n); + } else { + + /* "pywrapfst.pyx":1960 + * cdef void _delete_arcs(self, int64 state, size_t n=0) except *: + * if not (self._mfst.get().DeleteArcs(state, n) if n else + * self._mfst.get().DeleteArcs(state)): # <<<<<<<<<<<<<< + * raise FstIndexError("State index out of range") + * self._check_mutating_imethod() + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 1960, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_self->_mfst.get()->DeleteArcs(__pyx_v_state); + } + + /* "pywrapfst.pyx":1959 + * + * cdef void _delete_arcs(self, int64 state, size_t n=0) except *: + * if not (self._mfst.get().DeleteArcs(state, n) if n else # <<<<<<<<<<<<<< + * self._mfst.get().DeleteArcs(state)): + * raise FstIndexError("State index out of range") + */ + __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); + if (__pyx_t_2) { + + /* "pywrapfst.pyx":1961 + * if not (self._mfst.get().DeleteArcs(state, n) if n else + * self._mfst.get().DeleteArcs(state)): + * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1961, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__33, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1961, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 1961, __pyx_L1_error) + + /* "pywrapfst.pyx":1959 + * + * cdef void _delete_arcs(self, int64 state, size_t n=0) except *: + * if not (self._mfst.get().DeleteArcs(state, n) if n else # <<<<<<<<<<<<<< + * self._mfst.get().DeleteArcs(state)): + * raise FstIndexError("State index out of range") + */ + } + + /* "pywrapfst.pyx":1962 + * self._mfst.get().DeleteArcs(state)): + * raise FstIndexError("State index out of range") + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def delete_arcs(self, int64 state, size_t n=0): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 1962, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1962, __pyx_L1_error) + + /* "pywrapfst.pyx":1958 + * return self + * + * cdef void _delete_arcs(self, int64 state, size_t n=0) except *: # <<<<<<<<<<<<<< + * if not (self._mfst.get().DeleteArcs(state, n) if n else + * self._mfst.get().DeleteArcs(state)): + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pywrapfst._MutableFst._delete_arcs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":1964 + * self._check_mutating_imethod() + * + * def delete_arcs(self, int64 state, size_t n=0): # <<<<<<<<<<<<<< + * """ + * delete_arcs(self, state, n=0) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_15delete_arcs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_14delete_arcs[] = "\n delete_arcs(self, state, n=0)\n\n Deletes arcs leaving a particular state.\n\n Args:\n state: The integer index of a state.\n n: An optional argument indicating how many arcs to be deleted. If this\n argument is omitted or passed as zero, all arcs from this state are\n deleted.\n\n Returns:\n self.\n\n Raises:\n FstIndexError: State index out of range.\n\n See also: `delete_states`.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_15delete_arcs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + __pyx_t_10basictypes_int64 __pyx_v_state; + size_t __pyx_v_n; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("delete_arcs (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_state,&__pyx_n_s_n,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_n); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "delete_arcs") < 0)) __PYX_ERR(0, 1964, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_state = __Pyx_PyInt_As_int64_t(values[0]); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1964, __pyx_L3_error) + if (values[1]) { + __pyx_v_n = __Pyx_PyInt_As_size_t(values[1]); if (unlikely((__pyx_v_n == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 1964, __pyx_L3_error) + } else { + __pyx_v_n = ((size_t)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("delete_arcs", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1964, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.delete_arcs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_14delete_arcs(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_state, __pyx_v_n); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_14delete_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, size_t __pyx_v_n) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_arcs __pyx_t_1; + __Pyx_RefNannySetupContext("delete_arcs", 0); + + /* "pywrapfst.pyx":1984 + * See also: `delete_states`. + * """ + * self._delete_arcs(state, n) # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_delete_arcs"); + __PYX_ERR(0, 1984, __pyx_L1_error) + } + __pyx_t_1.__pyx_n = 1; + __pyx_t_1.n = __pyx_v_n; + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_delete_arcs(__pyx_v_self, __pyx_v_state, &__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1984, __pyx_L1_error) + + /* "pywrapfst.pyx":1985 + * """ + * self._delete_arcs(state, n) + * return self # <<<<<<<<<<<<<< + * + * cdef void _delete_states(self, states=None) except *: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":1964 + * self._check_mutating_imethod() + * + * def delete_arcs(self, int64 state, size_t n=0): # <<<<<<<<<<<<<< + * """ + * delete_arcs(self, state, n=0) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.delete_arcs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":1987 + * return self + * + * cdef void _delete_states(self, states=None) except *: # <<<<<<<<<<<<<< + * # Only the former signature has a possible indexing failure. + * if states: + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__delete_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_states *__pyx_optional_args) { + PyObject *__pyx_v_states = ((PyObject *)Py_None); + __Pyx_RefNannyDeclarations + int __pyx_t_1; + std::vector<__pyx_t_10basictypes_int64> __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("_delete_states", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_states = __pyx_optional_args->states; + } + } + + /* "pywrapfst.pyx":1989 + * cdef void _delete_states(self, states=None) except *: + * # Only the former signature has a possible indexing failure. + * if states: # <<<<<<<<<<<<<< + * if not self._mfst.get().DeleteStates( states): + * raise FstIndexError("State index out of range") + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_states); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1989, __pyx_L1_error) + if (__pyx_t_1) { + + /* "pywrapfst.pyx":1990 + * # Only the former signature has a possible indexing failure. + * if states: + * if not self._mfst.get().DeleteStates( states): # <<<<<<<<<<<<<< + * raise FstIndexError("State index out of range") + * else: + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 1990, __pyx_L1_error) + } + __pyx_t_2 = __pyx_convert_vector_from_py___pyx_t_10basictypes_int64(__pyx_v_states); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1990, __pyx_L1_error) + __pyx_t_1 = ((!(__pyx_v_self->_mfst.get()->DeleteStates(((std::vector<__pyx_t_10basictypes_int64> const )__pyx_t_2)) != 0)) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":1991 + * if states: + * if not self._mfst.get().DeleteStates( states): + * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< + * else: + * self._mfst.get().DeleteStates() + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1991, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__34, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1991, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 1991, __pyx_L1_error) + + /* "pywrapfst.pyx":1990 + * # Only the former signature has a possible indexing failure. + * if states: + * if not self._mfst.get().DeleteStates( states): # <<<<<<<<<<<<<< + * raise FstIndexError("State index out of range") + * else: + */ + } + + /* "pywrapfst.pyx":1989 + * cdef void _delete_states(self, states=None) except *: + * # Only the former signature has a possible indexing failure. + * if states: # <<<<<<<<<<<<<< + * if not self._mfst.get().DeleteStates( states): + * raise FstIndexError("State index out of range") + */ + goto __pyx_L3; + } + + /* "pywrapfst.pyx":1993 + * raise FstIndexError("State index out of range") + * else: + * self._mfst.get().DeleteStates() # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + /*else*/ { + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 1993, __pyx_L1_error) + } + __pyx_v_self->_mfst.get()->DeleteStates(); + } + __pyx_L3:; + + /* "pywrapfst.pyx":1994 + * else: + * self._mfst.get().DeleteStates() + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def delete_states(self, states=None): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 1994, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1994, __pyx_L1_error) + + /* "pywrapfst.pyx":1987 + * return self + * + * cdef void _delete_states(self, states=None) except *: # <<<<<<<<<<<<<< + * # Only the former signature has a possible indexing failure. + * if states: + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pywrapfst._MutableFst._delete_states", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":1996 + * self._check_mutating_imethod() + * + * def delete_states(self, states=None): # <<<<<<<<<<<<<< + * """ + * delete_states(self, states=None) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_17delete_states(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_16delete_states[] = "\n delete_states(self, states=None)\n\n Deletes states.\n\n Args:\n states: An optional iterable of integer indices of the states to be\n deleted. If this argument is omitted, all states are deleted.\n\n Returns:\n self.\n\n Raises:\n FstIndexError: State index out of range.\n\n See also: `delete_arcs`.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_17delete_states(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_states = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("delete_states (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_states,0}; + PyObject* values[1] = {0}; + values[0] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_states); + if (value) { values[0] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "delete_states") < 0)) __PYX_ERR(0, 1996, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_states = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("delete_states", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1996, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.delete_states", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_16delete_states(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_states); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_16delete_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, PyObject *__pyx_v_states) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_states __pyx_t_1; + __Pyx_RefNannySetupContext("delete_states", 0); + + /* "pywrapfst.pyx":2014 + * See also: `delete_arcs`. + * """ + * self._delete_states(states) # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_delete_states"); + __PYX_ERR(0, 2014, __pyx_L1_error) + } + __pyx_t_1.__pyx_n = 1; + __pyx_t_1.states = __pyx_v_states; + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_delete_states(__pyx_v_self, &__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2014, __pyx_L1_error) + + /* "pywrapfst.pyx":2015 + * """ + * self._delete_states(states) + * return self # <<<<<<<<<<<<<< + * + * cdef void _encode(self, EncodeMapper encoder) except *: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":1996 + * self._check_mutating_imethod() + * + * def delete_states(self, states=None): # <<<<<<<<<<<<<< + * """ + * delete_states(self, states=None) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.delete_states", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2017 + * return self + * + * cdef void _encode(self, EncodeMapper encoder) except *: # <<<<<<<<<<<<<< + * fst.Encode(self._mfst.get(), encoder._encoder.get()) + * self._check_mutating_imethod() + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__encode(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_encoder) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_encode", 0); + + /* "pywrapfst.pyx":2018 + * + * cdef void _encode(self, EncodeMapper encoder) except *: + * fst.Encode(self._mfst.get(), encoder._encoder.get()) # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2018, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_encoder) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_encoder"); + __PYX_ERR(0, 2018, __pyx_L1_error) + } + fst::script::Encode(__pyx_v_self->_mfst.get(), __pyx_v_encoder->_encoder.get()); + + /* "pywrapfst.pyx":2019 + * cdef void _encode(self, EncodeMapper encoder) except *: + * fst.Encode(self._mfst.get(), encoder._encoder.get()) + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def encode(self, EncodeMapper encoder): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 2019, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2019, __pyx_L1_error) + + /* "pywrapfst.pyx":2017 + * return self + * + * cdef void _encode(self, EncodeMapper encoder) except *: # <<<<<<<<<<<<<< + * fst.Encode(self._mfst.get(), encoder._encoder.get()) + * self._check_mutating_imethod() + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst._encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":2021 + * self._check_mutating_imethod() + * + * def encode(self, EncodeMapper encoder): # <<<<<<<<<<<<<< + * """ + * encode(self, encoder) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_19encode(PyObject *__pyx_v_self, PyObject *__pyx_v_encoder); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_18encode[] = "\n encode(self, encoder)\n\n Encodes labels and/or weights.\n\n This operation allows for the representation of a weighted transducer as a\n weighted acceptor, an unweighted transducer, or an unweighted acceptor by\n considering the pair (input label, output label), the pair (input label,\n weight), or the triple (input label, output label, weight) as a single\n label. Applying this operation mutates the EncodeMapper argument, which\n can then be used to decode.\n\n Args:\n encoder: An EncodeMapper object to be used as the encoder.\n\n Returns:\n self.\n\n See also: `decode`.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_19encode(PyObject *__pyx_v_self, PyObject *__pyx_v_encoder) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("encode (wrapper)", 0); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_encoder), __pyx_ptype_9pywrapfst_EncodeMapper, 1, "encoder", 0))) __PYX_ERR(0, 2021, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_18encode(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_encoder)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_18encode(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_encoder) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("encode", 0); + + /* "pywrapfst.pyx":2042 + * See also: `decode`. + * """ + * self._encode(encoder) # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_encode"); + __PYX_ERR(0, 2042, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_encode(__pyx_v_self, __pyx_v_encoder); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2042, __pyx_L1_error) + + /* "pywrapfst.pyx":2043 + * """ + * self._encode(encoder) + * return self # <<<<<<<<<<<<<< + * + * cdef void _invert(self) except *: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":2021 + * self._check_mutating_imethod() + * + * def encode(self, EncodeMapper encoder): # <<<<<<<<<<<<<< + * """ + * encode(self, encoder) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.encode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2045 + * return self + * + * cdef void _invert(self) except *: # <<<<<<<<<<<<<< + * fst.Invert(self._mfst.get()) + * self._check_mutating_imethod() + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__invert(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_invert", 0); + + /* "pywrapfst.pyx":2046 + * + * cdef void _invert(self) except *: + * fst.Invert(self._mfst.get()) # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2046, __pyx_L1_error) + } + fst::script::Invert(__pyx_v_self->_mfst.get()); + + /* "pywrapfst.pyx":2047 + * cdef void _invert(self) except *: + * fst.Invert(self._mfst.get()) + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def invert(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 2047, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2047, __pyx_L1_error) + + /* "pywrapfst.pyx":2045 + * return self + * + * cdef void _invert(self) except *: # <<<<<<<<<<<<<< + * fst.Invert(self._mfst.get()) + * self._check_mutating_imethod() + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst._invert", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":2049 + * self._check_mutating_imethod() + * + * def invert(self): # <<<<<<<<<<<<<< + * """ + * invert(self) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_21invert(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_20invert[] = "\n invert(self)\n\n Inverts the FST's transduction.\n\n This operation destructively inverts the FST's transduction by exchanging\n input and output labels.\n\n Returns:\n self.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_21invert(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("invert (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_20invert(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_20invert(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("invert", 0); + + /* "pywrapfst.pyx":2061 + * self. + * """ + * self._invert() # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_invert"); + __PYX_ERR(0, 2061, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_invert(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2061, __pyx_L1_error) + + /* "pywrapfst.pyx":2062 + * """ + * self._invert() + * return self # <<<<<<<<<<<<<< + * + * cdef void _minimize(self, float delta=fst.kShortestDelta, + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":2049 + * self._check_mutating_imethod() + * + * def invert(self): # <<<<<<<<<<<<<< + * """ + * invert(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.invert", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2064 + * return self + * + * cdef void _minimize(self, float delta=fst.kShortestDelta, # <<<<<<<<<<<<<< + * bool allow_nondet=False) except *: + * # This runs in-place when the second argument is null. + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__minimize(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__minimize *__pyx_optional_args) { + float __pyx_v_delta = __pyx_k__35; + + /* "pywrapfst.pyx":2065 + * + * cdef void _minimize(self, float delta=fst.kShortestDelta, + * bool allow_nondet=False) except *: # <<<<<<<<<<<<<< + * # This runs in-place when the second argument is null. + * fst.Minimize(self._mfst.get(), NULL, delta, allow_nondet) + */ + bool __pyx_v_allow_nondet = ((bool)0); + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_minimize", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_delta = __pyx_optional_args->delta; + if (__pyx_optional_args->__pyx_n > 1) { + __pyx_v_allow_nondet = __pyx_optional_args->allow_nondet; + } + } + } + + /* "pywrapfst.pyx":2067 + * bool allow_nondet=False) except *: + * # This runs in-place when the second argument is null. + * fst.Minimize(self._mfst.get(), NULL, delta, allow_nondet) # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2067, __pyx_L1_error) + } + fst::script::Minimize(__pyx_v_self->_mfst.get(), NULL, __pyx_v_delta, __pyx_v_allow_nondet); + + /* "pywrapfst.pyx":2068 + * # This runs in-place when the second argument is null. + * fst.Minimize(self._mfst.get(), NULL, delta, allow_nondet) + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def minimize(self, float delta=fst.kShortestDelta, bool allow_nondet=False): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 2068, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2068, __pyx_L1_error) + + /* "pywrapfst.pyx":2064 + * return self + * + * cdef void _minimize(self, float delta=fst.kShortestDelta, # <<<<<<<<<<<<<< + * bool allow_nondet=False) except *: + * # This runs in-place when the second argument is null. + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst._minimize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":2070 + * self._check_mutating_imethod() + * + * def minimize(self, float delta=fst.kShortestDelta, bool allow_nondet=False): # <<<<<<<<<<<<<< + * """ + * minimize(self, delta=1e-6, allow_nondet=False) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_23minimize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_22minimize[] = "\n minimize(self, delta=1e-6, allow_nondet=False)\n\n Minimizes the FST.\n\n This operation destructively performs the minimization of deterministic\n weighted automata and transducers. If the input FST A is an acceptor, this\n operation produces the minimal acceptor B equivalent to A, i.e. the\n acceptor with a minimal number of states that is equivalent to A. If the\n input FST A is a transducer, this operation internally builds an equivalent\n transducer with a minimal number of states. However, this minimality is\n obtained by allowing transition having strings of symbols as output labels,\n this known in the litterature as a real-time transducer. Such transducers\n are not directly supported by the library. This function will convert such\n transducer by expanding each string-labeled transition into a sequence of\n transitions. This will results in the creation of new states, hence losing\n the minimality property.\n\n Args:\n delta: Comparison/quantization delta.\n allow_nondet: Attempt minimization of non-deterministic FST?\n\n Returns:\n self.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_23minimize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + float __pyx_v_delta; + bool __pyx_v_allow_nondet; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("minimize (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_delta,&__pyx_n_s_allow_nondet,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta); + if (value) { values[0] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_allow_nondet); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "minimize") < 0)) __PYX_ERR(0, 2070, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + if (values[0]) { + __pyx_v_delta = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_delta == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2070, __pyx_L3_error) + } else { + __pyx_v_delta = __pyx_k__36; + } + if (values[1]) { + __pyx_v_allow_nondet = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_allow_nondet == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2070, __pyx_L3_error) + } else { + __pyx_v_allow_nondet = ((bool)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("minimize", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2070, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.minimize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_22minimize(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_delta, __pyx_v_allow_nondet); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_22minimize(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, float __pyx_v_delta, bool __pyx_v_allow_nondet) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + struct __pyx_opt_args_9pywrapfst_11_MutableFst__minimize __pyx_t_1; + __Pyx_RefNannySetupContext("minimize", 0); + + /* "pywrapfst.pyx":2096 + * self. + * """ + * self._minimize(delta, allow_nondet) # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_minimize"); + __PYX_ERR(0, 2096, __pyx_L1_error) + } + __pyx_t_1.__pyx_n = 2; + __pyx_t_1.delta = __pyx_v_delta; + __pyx_t_1.allow_nondet = __pyx_v_allow_nondet; + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_minimize(__pyx_v_self, &__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2096, __pyx_L1_error) + + /* "pywrapfst.pyx":2097 + * """ + * self._minimize(delta, allow_nondet) + * return self # <<<<<<<<<<<<<< + * + * cpdef MutableArcIterator mutable_arcs(self, int64 state): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":2070 + * self._check_mutating_imethod() + * + * def minimize(self, float delta=fst.kShortestDelta, bool allow_nondet=False): # <<<<<<<<<<<<<< + * """ + * minimize(self, delta=1e-6, allow_nondet=False) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.minimize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2099 + * return self + * + * cpdef MutableArcIterator mutable_arcs(self, int64 state): # <<<<<<<<<<<<<< + * """ + * mutable_arcs(self, state) + */ + +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_25mutable_arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ +static struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_f_9pywrapfst_11_MutableFst_mutable_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch) { + struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + __Pyx_RefNannySetupContext("mutable_arcs", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_mutable_arcs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2099, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_25mutable_arcs)) { + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_v_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2099, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2099, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2099, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2099, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2099, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2099, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pywrapfst_MutableArcIterator))))) __PYX_ERR(0, 2099, __pyx_L1_error) + __pyx_r = ((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_t_2); + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":2113 + * See also: `arcs`, `states`. + * """ + * return MutableArcIterator(self, state) # <<<<<<<<<<<<<< + * + * def mutable_input_symbols(self): + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_v_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pywrapfst_MutableArcIterator), __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = ((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":2099 + * return self + * + * cpdef MutableArcIterator mutable_arcs(self, int64 state): # <<<<<<<<<<<<<< + * """ + * mutable_arcs(self, state) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pywrapfst._MutableFst.mutable_arcs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_25mutable_arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_24mutable_arcs[] = "\n mutable_arcs(self, state)\n\n Returns a mutable iterator over arcs leaving the specified state.\n\n Args:\n state: The source state ID.\n\n Returns:\n A MutableArcIterator.\n\n See also: `arcs`, `states`.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_25mutable_arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state) { + __pyx_t_10basictypes_int64 __pyx_v_state; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("mutable_arcs (wrapper)", 0); + assert(__pyx_arg_state); { + __pyx_v_state = __Pyx_PyInt_As_int64_t(__pyx_arg_state); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2099, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.mutable_arcs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_24mutable_arcs(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), ((__pyx_t_10basictypes_int64)__pyx_v_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_24mutable_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("mutable_arcs", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_11_MutableFst_mutable_arcs(__pyx_v_self, __pyx_v_state, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2099, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._MutableFst.mutable_arcs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2115 + * return MutableArcIterator(self, state) + * + * def mutable_input_symbols(self): # <<<<<<<<<<<<<< + * """ + * mutable_input_symbols(self) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_27mutable_input_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_26mutable_input_symbols[] = "\n mutable_input_symbols(self)\n\n Returns the FST's (mutable) input symbol table, or None if none is present.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_27mutable_input_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("mutable_input_symbols (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_26mutable_input_symbols(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_26mutable_input_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self) { + fst::SymbolTable *__pyx_v_tst; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("mutable_input_symbols", 0); + + /* "pywrapfst.pyx":2121 + * Returns the FST's (mutable) input symbol table, or None if none is present. + * """ + * cdef fst.SymbolTable *tst = self._mfst.get().MutableInputSymbols() # <<<<<<<<<<<<<< + * if tst == NULL: + * return + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2121, __pyx_L1_error) + } + __pyx_v_tst = __pyx_v_self->_mfst.get()->MutableInputSymbols(); + + /* "pywrapfst.pyx":2122 + * """ + * cdef fst.SymbolTable *tst = self._mfst.get().MutableInputSymbols() + * if tst == NULL: # <<<<<<<<<<<<<< + * return + * return _init_MutableFstSymbolTable(tst, self._mfst) + */ + __pyx_t_1 = ((__pyx_v_tst == NULL) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":2123 + * cdef fst.SymbolTable *tst = self._mfst.get().MutableInputSymbols() + * if tst == NULL: + * return # <<<<<<<<<<<<<< + * return _init_MutableFstSymbolTable(tst, self._mfst) + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "pywrapfst.pyx":2122 + * """ + * cdef fst.SymbolTable *tst = self._mfst.get().MutableInputSymbols() + * if tst == NULL: # <<<<<<<<<<<<<< + * return + * return _init_MutableFstSymbolTable(tst, self._mfst) + */ + } + + /* "pywrapfst.pyx":2124 + * if tst == NULL: + * return + * return _init_MutableFstSymbolTable(tst, self._mfst) # <<<<<<<<<<<<<< + * + * def mutable_output_symbols(self): + */ + __Pyx_XDECREF(__pyx_r); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2124, __pyx_L1_error) + } + __pyx_t_2 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFstSymbolTable(__pyx_v_tst, __pyx_v_self->_mfst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":2115 + * return MutableArcIterator(self, state) + * + * def mutable_input_symbols(self): # <<<<<<<<<<<<<< + * """ + * mutable_input_symbols(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pywrapfst._MutableFst.mutable_input_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2126 + * return _init_MutableFstSymbolTable(tst, self._mfst) + * + * def mutable_output_symbols(self): # <<<<<<<<<<<<<< + * """ + * mutable_output_symbols(self) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_29mutable_output_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_28mutable_output_symbols[] = "\n mutable_output_symbols(self)\n\n Returns the FST's (mutable) output symbol table, or None if none is present.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_29mutable_output_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("mutable_output_symbols (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_28mutable_output_symbols(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_28mutable_output_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self) { + fst::SymbolTable *__pyx_v_tst; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("mutable_output_symbols", 0); + + /* "pywrapfst.pyx":2132 + * Returns the FST's (mutable) output symbol table, or None if none is present. + * """ + * cdef fst.SymbolTable *tst = self._mfst.get().MutableOutputSymbols() # <<<<<<<<<<<<<< + * if tst == NULL: + * return + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2132, __pyx_L1_error) + } + __pyx_v_tst = __pyx_v_self->_mfst.get()->MutableOutputSymbols(); + + /* "pywrapfst.pyx":2133 + * """ + * cdef fst.SymbolTable *tst = self._mfst.get().MutableOutputSymbols() + * if tst == NULL: # <<<<<<<<<<<<<< + * return + * return _init_MutableFstSymbolTable(tst, self._mfst) + */ + __pyx_t_1 = ((__pyx_v_tst == NULL) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":2134 + * cdef fst.SymbolTable *tst = self._mfst.get().MutableOutputSymbols() + * if tst == NULL: + * return # <<<<<<<<<<<<<< + * return _init_MutableFstSymbolTable(tst, self._mfst) + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "pywrapfst.pyx":2133 + * """ + * cdef fst.SymbolTable *tst = self._mfst.get().MutableOutputSymbols() + * if tst == NULL: # <<<<<<<<<<<<<< + * return + * return _init_MutableFstSymbolTable(tst, self._mfst) + */ + } + + /* "pywrapfst.pyx":2135 + * if tst == NULL: + * return + * return _init_MutableFstSymbolTable(tst, self._mfst) # <<<<<<<<<<<<<< + * + * cpdef int64 num_states(self): + */ + __Pyx_XDECREF(__pyx_r); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2135, __pyx_L1_error) + } + __pyx_t_2 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFstSymbolTable(__pyx_v_tst, __pyx_v_self->_mfst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":2126 + * return _init_MutableFstSymbolTable(tst, self._mfst) + * + * def mutable_output_symbols(self): # <<<<<<<<<<<<<< + * """ + * mutable_output_symbols(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pywrapfst._MutableFst.mutable_output_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2137 + * return _init_MutableFstSymbolTable(tst, self._mfst) + * + * cpdef int64 num_states(self): # <<<<<<<<<<<<<< + * """ + * num_states(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_31num_states(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_11_MutableFst_num_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, int __pyx_skip_dispatch) { + __pyx_t_10basictypes_int64 __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __pyx_t_10basictypes_int64 __pyx_t_5; + __Pyx_RefNannySetupContext("num_states", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_num_states); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_31num_states)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2137, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2137, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2137, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":2143 + * Returns the number of states. + * """ + * return self._mfst.get().NumStates() # <<<<<<<<<<<<<< + * + * cdef void _project(self, bool project_output=False) except *: + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2143, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_mfst.get()->NumStates(); + goto __pyx_L0; + + /* "pywrapfst.pyx":2137 + * return _init_MutableFstSymbolTable(tst, self._mfst) + * + * cpdef int64 num_states(self): # <<<<<<<<<<<<<< + * """ + * num_states(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst._MutableFst.num_states", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_31num_states(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_30num_states[] = "\n num_states(self)\n\n Returns the number of states.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_31num_states(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("num_states (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_30num_states(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_30num_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("num_states", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_f_9pywrapfst_11_MutableFst_num_states(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._MutableFst.num_states", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2145 + * return self._mfst.get().NumStates() + * + * cdef void _project(self, bool project_output=False) except *: # <<<<<<<<<<<<<< + * fst.Project(self._mfst.get(), fst.GetProjectType(project_output)) + * self._check_mutating_imethod() + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__project(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__project *__pyx_optional_args) { + bool __pyx_v_project_output = ((bool)0); + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_project", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_project_output = __pyx_optional_args->project_output; + } + } + + /* "pywrapfst.pyx":2146 + * + * cdef void _project(self, bool project_output=False) except *: + * fst.Project(self._mfst.get(), fst.GetProjectType(project_output)) # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2146, __pyx_L1_error) + } + fst::script::Project(__pyx_v_self->_mfst.get(), fst::script::GetProjectType(__pyx_v_project_output)); + + /* "pywrapfst.pyx":2147 + * cdef void _project(self, bool project_output=False) except *: + * fst.Project(self._mfst.get(), fst.GetProjectType(project_output)) + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def project(self, bool project_output=False): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 2147, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2147, __pyx_L1_error) + + /* "pywrapfst.pyx":2145 + * return self._mfst.get().NumStates() + * + * cdef void _project(self, bool project_output=False) except *: # <<<<<<<<<<<<<< + * fst.Project(self._mfst.get(), fst.GetProjectType(project_output)) + * self._check_mutating_imethod() + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst._project", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":2149 + * self._check_mutating_imethod() + * + * def project(self, bool project_output=False): # <<<<<<<<<<<<<< + * """ + * project(self, project_output=False) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_33project(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_32project[] = "\n project(self, project_output=False)\n\n Converts the FST to an acceptor using input or output labels.\n\n This operation destructively projects an FST onto its domain or range by\n either copying each arc's input label to its output label (the default) or\n vice versa.\n\n Args:\n project_output: Should the output labels be projected?\n\n Returns:\n self.\n\n See also: `decode`, `encode`, `relabel_pairs`, `relabel_symbols`.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_33project(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + bool __pyx_v_project_output; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("project (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_project_output,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_project_output); + if (value) { values[0] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "project") < 0)) __PYX_ERR(0, 2149, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + if (values[0]) { + __pyx_v_project_output = __Pyx_PyObject_IsTrue(values[0]); if (unlikely((__pyx_v_project_output == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2149, __pyx_L3_error) + } else { + __pyx_v_project_output = ((bool)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("project", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2149, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.project", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_32project(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_project_output); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_32project(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, bool __pyx_v_project_output) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + struct __pyx_opt_args_9pywrapfst_11_MutableFst__project __pyx_t_1; + __Pyx_RefNannySetupContext("project", 0); + + /* "pywrapfst.pyx":2167 + * See also: `decode`, `encode`, `relabel_pairs`, `relabel_symbols`. + * """ + * self._project(project_output) # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_project"); + __PYX_ERR(0, 2167, __pyx_L1_error) + } + __pyx_t_1.__pyx_n = 1; + __pyx_t_1.project_output = __pyx_v_project_output; + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_project(__pyx_v_self, &__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2167, __pyx_L1_error) + + /* "pywrapfst.pyx":2168 + * """ + * self._project(project_output) + * return self # <<<<<<<<<<<<<< + * + * cdef void _prune(self, float delta=fst.kDelta, int64 nstate=fst.kNoStateId, + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":2149 + * self._check_mutating_imethod() + * + * def project(self, bool project_output=False): # <<<<<<<<<<<<<< + * """ + * project(self, project_output=False) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.project", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2170 + * return self + * + * cdef void _prune(self, float delta=fst.kDelta, int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< + * weight=None) except *: + * # Threshold is set to semiring Zero (no pruning) if no weight is specified. + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__prune(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__prune *__pyx_optional_args) { + float __pyx_v_delta = __pyx_k__37; + __pyx_t_10basictypes_int64 __pyx_v_nstate = __pyx_k__38; + + /* "pywrapfst.pyx":2171 + * + * cdef void _prune(self, float delta=fst.kDelta, int64 nstate=fst.kNoStateId, + * weight=None) except *: # <<<<<<<<<<<<<< + * # Threshold is set to semiring Zero (no pruning) if no weight is specified. + * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(self.weight_type(), + */ + PyObject *__pyx_v_weight = ((PyObject *)Py_None); + fst::script::WeightClass __pyx_v_wc; + __Pyx_RefNannyDeclarations + fst::script::WeightClass __pyx_t_1; + __Pyx_RefNannySetupContext("_prune", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_delta = __pyx_optional_args->delta; + if (__pyx_optional_args->__pyx_n > 1) { + __pyx_v_nstate = __pyx_optional_args->nstate; + if (__pyx_optional_args->__pyx_n > 2) { + __pyx_v_weight = __pyx_optional_args->weight; + } + } + } + } + + /* "pywrapfst.pyx":2173 + * weight=None) except *: + * # Threshold is set to semiring Zero (no pruning) if no weight is specified. + * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(self.weight_type(), # <<<<<<<<<<<<<< + * weight) + * fst.Prune(self._mfst.get(), wc, nstate, delta) + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "weight_type"); + __PYX_ERR(0, 2173, __pyx_L1_error) + } + + /* "pywrapfst.pyx":2174 + * # Threshold is set to semiring Zero (no pruning) if no weight is specified. + * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(self.weight_type(), + * weight) # <<<<<<<<<<<<<< + * fst.Prune(self._mfst.get(), wc, nstate, delta) + * self._check_mutating_imethod() + */ + __pyx_t_1 = __pyx_f_9pywrapfst__get_WeightClass_or_Zero(((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.weight_type(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), 0), __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2173, __pyx_L1_error) + __pyx_v_wc = __pyx_t_1; + + /* "pywrapfst.pyx":2175 + * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(self.weight_type(), + * weight) + * fst.Prune(self._mfst.get(), wc, nstate, delta) # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2175, __pyx_L1_error) + } + fst::script::Prune(__pyx_v_self->_mfst.get(), __pyx_v_wc, __pyx_v_nstate, __pyx_v_delta); + + /* "pywrapfst.pyx":2176 + * weight) + * fst.Prune(self._mfst.get(), wc, nstate, delta) + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def prune(self, + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 2176, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2176, __pyx_L1_error) + + /* "pywrapfst.pyx":2170 + * return self + * + * cdef void _prune(self, float delta=fst.kDelta, int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< + * weight=None) except *: + * # Threshold is set to semiring Zero (no pruning) if no weight is specified. + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst._prune", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":2178 + * self._check_mutating_imethod() + * + * def prune(self, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * int64 nstate=fst.kNoStateId, + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_35prune(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_34prune[] = "\n prune(self, delta=0.0009765625, nstate=NO_STATE_ID, weight=None)\n\n Removes paths with weights below a certain threshold.\n\n This operation deletes states and arcs in the input FST that do not belong\n to a successful path whose weight is no more (w.r.t the natural semiring\n order) than the threshold t \\otimes-times the weight of the shortest path in\n the input FST. Weights must be commutative and have the path property.\n\n Args:\n delta: Comparison/quantization delta.\n nstate: State number threshold.\n weight: A Weight or weight string indicating the desired weight threshold\n below which paths are pruned; if omitted, no paths are pruned.\n\n Returns:\n self.\n\n See also: The constructive variant.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_35prune(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + float __pyx_v_delta; + __pyx_t_10basictypes_int64 __pyx_v_nstate; + PyObject *__pyx_v_weight = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("prune (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_delta,&__pyx_n_s_nstate,&__pyx_n_s_weight,0}; + PyObject* values[3] = {0,0,0}; + + /* "pywrapfst.pyx":2181 + * float delta=fst.kDelta, + * int64 nstate=fst.kNoStateId, + * weight=None): # <<<<<<<<<<<<<< + * """ + * prune(self, delta=0.0009765625, nstate=NO_STATE_ID, weight=None) + */ + values[2] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta); + if (value) { values[0] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nstate); + if (value) { values[1] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weight); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "prune") < 0)) __PYX_ERR(0, 2178, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + if (values[0]) { + __pyx_v_delta = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_delta == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2179, __pyx_L3_error) + } else { + __pyx_v_delta = __pyx_k__39; + } + if (values[1]) { + __pyx_v_nstate = __Pyx_PyInt_As_int64_t(values[1]); if (unlikely((__pyx_v_nstate == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2180, __pyx_L3_error) + } else { + __pyx_v_nstate = __pyx_k__40; + } + __pyx_v_weight = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("prune", 0, 0, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2178, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.prune", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_34prune(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_delta, __pyx_v_nstate, __pyx_v_weight); + + /* "pywrapfst.pyx":2178 + * self._check_mutating_imethod() + * + * def prune(self, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * int64 nstate=fst.kNoStateId, + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_34prune(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, float __pyx_v_delta, __pyx_t_10basictypes_int64 __pyx_v_nstate, PyObject *__pyx_v_weight) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + struct __pyx_opt_args_9pywrapfst_11_MutableFst__prune __pyx_t_1; + __Pyx_RefNannySetupContext("prune", 0); + + /* "pywrapfst.pyx":2203 + * See also: The constructive variant. + * """ + * self._prune(delta, nstate, weight) # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_prune"); + __PYX_ERR(0, 2203, __pyx_L1_error) + } + __pyx_t_1.__pyx_n = 3; + __pyx_t_1.delta = __pyx_v_delta; + __pyx_t_1.nstate = __pyx_v_nstate; + __pyx_t_1.weight = __pyx_v_weight; + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_prune(__pyx_v_self, &__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2203, __pyx_L1_error) + + /* "pywrapfst.pyx":2204 + * """ + * self._prune(delta, nstate, weight) + * return self # <<<<<<<<<<<<<< + * + * cdef void _push(self, + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":2178 + * self._check_mutating_imethod() + * + * def prune(self, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * int64 nstate=fst.kNoStateId, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.prune", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2206 + * return self + * + * cdef void _push(self, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * bool remove_total_weight=False, + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__push(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__push *__pyx_optional_args) { + float __pyx_v_delta = __pyx_k__41; + + /* "pywrapfst.pyx":2208 + * cdef void _push(self, + * float delta=fst.kDelta, + * bool remove_total_weight=False, # <<<<<<<<<<<<<< + * bool to_final=False) except *: + * fst.Push(self._mfst.get(), fst.GetReweightType(to_final), delta, + */ + bool __pyx_v_remove_total_weight = ((bool)0); + + /* "pywrapfst.pyx":2209 + * float delta=fst.kDelta, + * bool remove_total_weight=False, + * bool to_final=False) except *: # <<<<<<<<<<<<<< + * fst.Push(self._mfst.get(), fst.GetReweightType(to_final), delta, + * remove_total_weight) + */ + bool __pyx_v_to_final = ((bool)0); + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_push", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_delta = __pyx_optional_args->delta; + if (__pyx_optional_args->__pyx_n > 1) { + __pyx_v_remove_total_weight = __pyx_optional_args->remove_total_weight; + if (__pyx_optional_args->__pyx_n > 2) { + __pyx_v_to_final = __pyx_optional_args->to_final; + } + } + } + } + + /* "pywrapfst.pyx":2210 + * bool remove_total_weight=False, + * bool to_final=False) except *: + * fst.Push(self._mfst.get(), fst.GetReweightType(to_final), delta, # <<<<<<<<<<<<<< + * remove_total_weight) + * self._check_mutating_imethod() + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2210, __pyx_L1_error) + } + + /* "pywrapfst.pyx":2211 + * bool to_final=False) except *: + * fst.Push(self._mfst.get(), fst.GetReweightType(to_final), delta, + * remove_total_weight) # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + fst::script::Push(__pyx_v_self->_mfst.get(), fst::script::GetReweightType(__pyx_v_to_final), __pyx_v_delta, __pyx_v_remove_total_weight); + + /* "pywrapfst.pyx":2212 + * fst.Push(self._mfst.get(), fst.GetReweightType(to_final), delta, + * remove_total_weight) + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def push(self, + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 2212, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2212, __pyx_L1_error) + + /* "pywrapfst.pyx":2206 + * return self + * + * cdef void _push(self, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * bool remove_total_weight=False, + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst._push", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":2214 + * self._check_mutating_imethod() + * + * def push(self, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * bool remove_total_weight=False, + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_37push(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_36push[] = "\n push(self, delta=0.0009765625, remove_total_weight=False, to_final=False)\n\n Pushes weights towards the initial or final states.\n\n This operation destructively produces an equivalent transducer by pushing\n the weights towards the initial state or toward the final states. When\n pushing weights towards the initial state, the sum of the weight of the\n outgoing transitions and final weight at any non-initial state is equal to\n one in the resulting machine. When pushing weights towards the final states,\n the sum of the weight of the incoming transitions at any state is equal to\n one. Weights need to be left distributive when pushing towards the initial\n state and right distributive when pushing towards the final states.\n\n Args:\n delta: Comparison/quantization delta.\n remove_total_weight: If pushing weights, should the total weight be\n removed?\n to_final: Push towards final states?\n\n Returns:\n self.\n\n See also: The constructive variant, which also supports label pushing.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_37push(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + float __pyx_v_delta; + bool __pyx_v_remove_total_weight; + bool __pyx_v_to_final; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("push (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_delta,&__pyx_n_s_remove_total_weight,&__pyx_n_s_to_final,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta); + if (value) { values[0] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_remove_total_weight); + if (value) { values[1] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_to_final); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "push") < 0)) __PYX_ERR(0, 2214, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + if (values[0]) { + __pyx_v_delta = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_delta == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2215, __pyx_L3_error) + } else { + __pyx_v_delta = __pyx_k__42; + } + if (values[1]) { + __pyx_v_remove_total_weight = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_remove_total_weight == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2216, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":2216 + * def push(self, + * float delta=fst.kDelta, + * bool remove_total_weight=False, # <<<<<<<<<<<<<< + * bool to_final=False): + * """ + */ + __pyx_v_remove_total_weight = ((bool)0); + } + if (values[2]) { + __pyx_v_to_final = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_to_final == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2217, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":2217 + * float delta=fst.kDelta, + * bool remove_total_weight=False, + * bool to_final=False): # <<<<<<<<<<<<<< + * """ + * push(self, delta=0.0009765625, remove_total_weight=False, to_final=False) + */ + __pyx_v_to_final = ((bool)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("push", 0, 0, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2214, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.push", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_36push(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_delta, __pyx_v_remove_total_weight, __pyx_v_to_final); + + /* "pywrapfst.pyx":2214 + * self._check_mutating_imethod() + * + * def push(self, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * bool remove_total_weight=False, + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_36push(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, float __pyx_v_delta, bool __pyx_v_remove_total_weight, bool __pyx_v_to_final) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + struct __pyx_opt_args_9pywrapfst_11_MutableFst__push __pyx_t_1; + __Pyx_RefNannySetupContext("push", 0); + + /* "pywrapfst.pyx":2243 + * See also: The constructive variant, which also supports label pushing. + * """ + * self._push(delta, remove_total_weight, to_final) # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_push"); + __PYX_ERR(0, 2243, __pyx_L1_error) + } + __pyx_t_1.__pyx_n = 3; + __pyx_t_1.delta = __pyx_v_delta; + __pyx_t_1.remove_total_weight = __pyx_v_remove_total_weight; + __pyx_t_1.to_final = __pyx_v_to_final; + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_push(__pyx_v_self, &__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2243, __pyx_L1_error) + + /* "pywrapfst.pyx":2244 + * """ + * self._push(delta, remove_total_weight, to_final) + * return self # <<<<<<<<<<<<<< + * + * cdef void _relabel_pairs(self, ipairs=None, opairs=None) except *: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":2214 + * self._check_mutating_imethod() + * + * def push(self, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * bool remove_total_weight=False, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.push", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2246 + * return self + * + * cdef void _relabel_pairs(self, ipairs=None, opairs=None) except *: # <<<<<<<<<<<<<< + * cdef unique_ptr[vector[fst.LabelPair]] _ipairs + * _ipairs.reset(new vector[fst.LabelPair]()) + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__relabel_pairs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_pairs *__pyx_optional_args) { + PyObject *__pyx_v_ipairs = ((PyObject *)Py_None); + PyObject *__pyx_v_opairs = ((PyObject *)Py_None); + std::unique_ptr > __pyx_v__ipairs; + std::unique_ptr > __pyx_v__opairs; + __pyx_t_10basictypes_int64 __pyx_v_before; + __pyx_t_10basictypes_int64 __pyx_v_after; + __Pyx_RefNannyDeclarations + std::vector<__pyx_t_3fst_LabelPair> *__pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + PyObject *(*__pyx_t_5)(PyObject *); + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *(*__pyx_t_10)(PyObject *); + __pyx_t_10basictypes_int64 __pyx_t_11; + __pyx_t_10basictypes_int64 __pyx_t_12; + __pyx_t_3fst_LabelPair __pyx_t_13; + int __pyx_t_14; + __Pyx_RefNannySetupContext("_relabel_pairs", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_ipairs = __pyx_optional_args->ipairs; + if (__pyx_optional_args->__pyx_n > 1) { + __pyx_v_opairs = __pyx_optional_args->opairs; + } + } + } + + /* "pywrapfst.pyx":2248 + * cdef void _relabel_pairs(self, ipairs=None, opairs=None) except *: + * cdef unique_ptr[vector[fst.LabelPair]] _ipairs + * _ipairs.reset(new vector[fst.LabelPair]()) # <<<<<<<<<<<<<< + * cdef unique_ptr[vector[fst.LabelPair]] _opairs + * _opairs.reset(new vector[fst.LabelPair]()) + */ + try { + __pyx_t_1 = new std::vector<__pyx_t_3fst_LabelPair> (); + } catch(...) { + __Pyx_CppExn2PyErr(); + __PYX_ERR(0, 2248, __pyx_L1_error) + } + __pyx_v__ipairs.reset(__pyx_t_1); + + /* "pywrapfst.pyx":2250 + * _ipairs.reset(new vector[fst.LabelPair]()) + * cdef unique_ptr[vector[fst.LabelPair]] _opairs + * _opairs.reset(new vector[fst.LabelPair]()) # <<<<<<<<<<<<<< + * cdef int64 before + * cdef int64 after + */ + try { + __pyx_t_1 = new std::vector<__pyx_t_3fst_LabelPair> (); + } catch(...) { + __Pyx_CppExn2PyErr(); + __PYX_ERR(0, 2250, __pyx_L1_error) + } + __pyx_v__opairs.reset(__pyx_t_1); + + /* "pywrapfst.pyx":2253 + * cdef int64 before + * cdef int64 after + * if ipairs: # <<<<<<<<<<<<<< + * for (before, after) in ipairs: + * _ipairs.get().push_back(fst.LabelPair(before, after)) + */ + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_ipairs); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2253, __pyx_L1_error) + if (__pyx_t_2) { + + /* "pywrapfst.pyx":2254 + * cdef int64 after + * if ipairs: + * for (before, after) in ipairs: # <<<<<<<<<<<<<< + * _ipairs.get().push_back(fst.LabelPair(before, after)) + * if opairs: + */ + if (likely(PyList_CheckExact(__pyx_v_ipairs)) || PyTuple_CheckExact(__pyx_v_ipairs)) { + __pyx_t_3 = __pyx_v_ipairs; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0; + __pyx_t_5 = NULL; + } else { + __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_ipairs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2254, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_5)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_6 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 2254, __pyx_L1_error) + #else + __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + } else { + if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 2254, __pyx_L1_error) + #else + __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + } + } else { + __pyx_t_6 = __pyx_t_5(__pyx_t_3); + if (unlikely(!__pyx_t_6)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 2254, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_6); + } + if ((likely(PyTuple_CheckExact(__pyx_t_6))) || (PyList_CheckExact(__pyx_t_6))) { + PyObject* sequence = __pyx_t_6; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 2254, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_7 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_7 = PyList_GET_ITEM(sequence, 0); + __pyx_t_8 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + #else + __pyx_t_7 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_9 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext; + index = 0; __pyx_t_7 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_7)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_7); + index = 1; __pyx_t_8 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_8)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 2) < 0) __PYX_ERR(0, 2254, __pyx_L1_error) + __pyx_t_10 = NULL; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L7_unpacking_done; + __pyx_L6_unpacking_failed:; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_10 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 2254, __pyx_L1_error) + __pyx_L7_unpacking_done:; + } + __pyx_t_11 = __Pyx_PyInt_As_int64_t(__pyx_t_7); if (unlikely((__pyx_t_11 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2254, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_12 = __Pyx_PyInt_As_int64_t(__pyx_t_8); if (unlikely((__pyx_t_12 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2254, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_v_before = __pyx_t_11; + __pyx_v_after = __pyx_t_12; + + /* "pywrapfst.pyx":2255 + * if ipairs: + * for (before, after) in ipairs: + * _ipairs.get().push_back(fst.LabelPair(before, after)) # <<<<<<<<<<<<<< + * if opairs: + * for (before, after) in opairs: + */ + try { + __pyx_t_13 = __pyx_t_3fst_LabelPair(__pyx_v_before, __pyx_v_after); + } catch(...) { + __Pyx_CppExn2PyErr(); + __PYX_ERR(0, 2255, __pyx_L1_error) + } + try { + __pyx_v__ipairs.get()->push_back(__pyx_t_13); + } catch(...) { + __Pyx_CppExn2PyErr(); + __PYX_ERR(0, 2255, __pyx_L1_error) + } + + /* "pywrapfst.pyx":2254 + * cdef int64 after + * if ipairs: + * for (before, after) in ipairs: # <<<<<<<<<<<<<< + * _ipairs.get().push_back(fst.LabelPair(before, after)) + * if opairs: + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "pywrapfst.pyx":2253 + * cdef int64 before + * cdef int64 after + * if ipairs: # <<<<<<<<<<<<<< + * for (before, after) in ipairs: + * _ipairs.get().push_back(fst.LabelPair(before, after)) + */ + } + + /* "pywrapfst.pyx":2256 + * for (before, after) in ipairs: + * _ipairs.get().push_back(fst.LabelPair(before, after)) + * if opairs: # <<<<<<<<<<<<<< + * for (before, after) in opairs: + * _opairs.get().push_back(fst.LabelPair(before, after)) + */ + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_opairs); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2256, __pyx_L1_error) + if (__pyx_t_2) { + + /* "pywrapfst.pyx":2257 + * _ipairs.get().push_back(fst.LabelPair(before, after)) + * if opairs: + * for (before, after) in opairs: # <<<<<<<<<<<<<< + * _opairs.get().push_back(fst.LabelPair(before, after)) + * if _ipairs.get().empty() and _opairs.get().empty(): + */ + if (likely(PyList_CheckExact(__pyx_v_opairs)) || PyTuple_CheckExact(__pyx_v_opairs)) { + __pyx_t_3 = __pyx_v_opairs; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0; + __pyx_t_5 = NULL; + } else { + __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_opairs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2257, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_5)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_6 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 2257, __pyx_L1_error) + #else + __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + } else { + if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 2257, __pyx_L1_error) + #else + __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + } + } else { + __pyx_t_6 = __pyx_t_5(__pyx_t_3); + if (unlikely(!__pyx_t_6)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 2257, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_6); + } + if ((likely(PyTuple_CheckExact(__pyx_t_6))) || (PyList_CheckExact(__pyx_t_6))) { + PyObject* sequence = __pyx_t_6; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 2257, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_8 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_8 = PyList_GET_ITEM(sequence, 0); + __pyx_t_7 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx_t_7); + #else + __pyx_t_8 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_9 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext; + index = 0; __pyx_t_8 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_8)) goto __pyx_L11_unpacking_failed; + __Pyx_GOTREF(__pyx_t_8); + index = 1; __pyx_t_7 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_7)) goto __pyx_L11_unpacking_failed; + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 2) < 0) __PYX_ERR(0, 2257, __pyx_L1_error) + __pyx_t_10 = NULL; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L12_unpacking_done; + __pyx_L11_unpacking_failed:; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_10 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 2257, __pyx_L1_error) + __pyx_L12_unpacking_done:; + } + __pyx_t_12 = __Pyx_PyInt_As_int64_t(__pyx_t_8); if (unlikely((__pyx_t_12 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2257, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_11 = __Pyx_PyInt_As_int64_t(__pyx_t_7); if (unlikely((__pyx_t_11 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2257, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_before = __pyx_t_12; + __pyx_v_after = __pyx_t_11; + + /* "pywrapfst.pyx":2258 + * if opairs: + * for (before, after) in opairs: + * _opairs.get().push_back(fst.LabelPair(before, after)) # <<<<<<<<<<<<<< + * if _ipairs.get().empty() and _opairs.get().empty(): + * raise FstArgError("No relabeling pairs specified.") + */ + try { + __pyx_t_13 = __pyx_t_3fst_LabelPair(__pyx_v_before, __pyx_v_after); + } catch(...) { + __Pyx_CppExn2PyErr(); + __PYX_ERR(0, 2258, __pyx_L1_error) + } + try { + __pyx_v__opairs.get()->push_back(__pyx_t_13); + } catch(...) { + __Pyx_CppExn2PyErr(); + __PYX_ERR(0, 2258, __pyx_L1_error) + } + + /* "pywrapfst.pyx":2257 + * _ipairs.get().push_back(fst.LabelPair(before, after)) + * if opairs: + * for (before, after) in opairs: # <<<<<<<<<<<<<< + * _opairs.get().push_back(fst.LabelPair(before, after)) + * if _ipairs.get().empty() and _opairs.get().empty(): + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "pywrapfst.pyx":2256 + * for (before, after) in ipairs: + * _ipairs.get().push_back(fst.LabelPair(before, after)) + * if opairs: # <<<<<<<<<<<<<< + * for (before, after) in opairs: + * _opairs.get().push_back(fst.LabelPair(before, after)) + */ + } + + /* "pywrapfst.pyx":2259 + * for (before, after) in opairs: + * _opairs.get().push_back(fst.LabelPair(before, after)) + * if _ipairs.get().empty() and _opairs.get().empty(): # <<<<<<<<<<<<<< + * raise FstArgError("No relabeling pairs specified.") + * fst.Relabel(self._mfst.get(), deref(_ipairs), deref(_opairs)) + */ + __pyx_t_14 = (__pyx_v__ipairs.get()->empty() != 0); + if (__pyx_t_14) { + } else { + __pyx_t_2 = __pyx_t_14; + goto __pyx_L14_bool_binop_done; + } + __pyx_t_14 = (__pyx_v__opairs.get()->empty() != 0); + __pyx_t_2 = __pyx_t_14; + __pyx_L14_bool_binop_done:; + if (__pyx_t_2) { + + /* "pywrapfst.pyx":2260 + * _opairs.get().push_back(fst.LabelPair(before, after)) + * if _ipairs.get().empty() and _opairs.get().empty(): + * raise FstArgError("No relabeling pairs specified.") # <<<<<<<<<<<<<< + * fst.Relabel(self._mfst.get(), deref(_ipairs), deref(_opairs)) + * self._check_mutating_imethod() + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__43, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 2260, __pyx_L1_error) + + /* "pywrapfst.pyx":2259 + * for (before, after) in opairs: + * _opairs.get().push_back(fst.LabelPair(before, after)) + * if _ipairs.get().empty() and _opairs.get().empty(): # <<<<<<<<<<<<<< + * raise FstArgError("No relabeling pairs specified.") + * fst.Relabel(self._mfst.get(), deref(_ipairs), deref(_opairs)) + */ + } + + /* "pywrapfst.pyx":2261 + * if _ipairs.get().empty() and _opairs.get().empty(): + * raise FstArgError("No relabeling pairs specified.") + * fst.Relabel(self._mfst.get(), deref(_ipairs), deref(_opairs)) # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2261, __pyx_L1_error) + } + fst::script::Relabel(__pyx_v_self->_mfst.get(), (*__pyx_v__ipairs), (*__pyx_v__opairs)); + + /* "pywrapfst.pyx":2262 + * raise FstArgError("No relabeling pairs specified.") + * fst.Relabel(self._mfst.get(), deref(_ipairs), deref(_opairs)) + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def relabel_pairs(self, ipairs=None, opairs=None): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 2262, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2262, __pyx_L1_error) + + /* "pywrapfst.pyx":2246 + * return self + * + * cdef void _relabel_pairs(self, ipairs=None, opairs=None) except *: # <<<<<<<<<<<<<< + * cdef unique_ptr[vector[fst.LabelPair]] _ipairs + * _ipairs.reset(new vector[fst.LabelPair]()) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("pywrapfst._MutableFst._relabel_pairs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":2264 + * self._check_mutating_imethod() + * + * def relabel_pairs(self, ipairs=None, opairs=None): # <<<<<<<<<<<<<< + * """ + * relabel_pairs(self, ipairs=None, opairs=None) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_39relabel_pairs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_38relabel_pairs[] = "\n relabel_pairs(self, ipairs=None, opairs=None)\n\n Replaces input and/or output labels using pairs of labels.\n\n This operation destructively relabels the input and/or output labels of the\n FST using pairs of the form (old_ID, new_ID); omitted indices are\n identity-mapped.\n\n Args:\n ipairs: An iterable containing (older index, newer index) integer pairs.\n opairs: An iterable containing (older index, newer index) integer pairs.\n\n Returns:\n self.\n\n Raises:\n FstArgError: No relabeling pairs specified.\n\n See also: `decode`, `encode`, `project`, `relabel_tables`.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_39relabel_pairs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_ipairs = 0; + PyObject *__pyx_v_opairs = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("relabel_pairs (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ipairs,&__pyx_n_s_opairs,0}; + PyObject* values[2] = {0,0}; + values[0] = ((PyObject *)Py_None); + values[1] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ipairs); + if (value) { values[0] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_opairs); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "relabel_pairs") < 0)) __PYX_ERR(0, 2264, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ipairs = values[0]; + __pyx_v_opairs = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("relabel_pairs", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2264, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.relabel_pairs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_38relabel_pairs(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_ipairs, __pyx_v_opairs); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_38relabel_pairs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, PyObject *__pyx_v_ipairs, PyObject *__pyx_v_opairs) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_pairs __pyx_t_1; + __Pyx_RefNannySetupContext("relabel_pairs", 0); + + /* "pywrapfst.pyx":2286 + * See also: `decode`, `encode`, `project`, `relabel_tables`. + * """ + * self._relabel_pairs(ipairs, opairs) # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_relabel_pairs"); + __PYX_ERR(0, 2286, __pyx_L1_error) + } + __pyx_t_1.__pyx_n = 2; + __pyx_t_1.ipairs = __pyx_v_ipairs; + __pyx_t_1.opairs = __pyx_v_opairs; + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_relabel_pairs(__pyx_v_self, &__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2286, __pyx_L1_error) + + /* "pywrapfst.pyx":2287 + * """ + * self._relabel_pairs(ipairs, opairs) + * return self # <<<<<<<<<<<<<< + * + * cdef void _relabel_tables(self, + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":2264 + * self._check_mutating_imethod() + * + * def relabel_pairs(self, ipairs=None, opairs=None): # <<<<<<<<<<<<<< + * """ + * relabel_pairs(self, ipairs=None, opairs=None) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.relabel_pairs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2289 + * return self + * + * cdef void _relabel_tables(self, # <<<<<<<<<<<<<< + * _SymbolTable old_isymbols=None, + * _SymbolTable new_isymbols=None, + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__relabel_tables(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_tables *__pyx_optional_args) { + + /* "pywrapfst.pyx":2290 + * + * cdef void _relabel_tables(self, + * _SymbolTable old_isymbols=None, # <<<<<<<<<<<<<< + * _SymbolTable new_isymbols=None, + * unknown_isymbol=b"", + */ + struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_old_isymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None); + + /* "pywrapfst.pyx":2291 + * cdef void _relabel_tables(self, + * _SymbolTable old_isymbols=None, + * _SymbolTable new_isymbols=None, # <<<<<<<<<<<<<< + * unknown_isymbol=b"", + * bool attach_new_isymbols=True, + */ + struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_new_isymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None); + PyObject *__pyx_v_unknown_isymbol = ((PyObject *)__pyx_kp_b__24); + + /* "pywrapfst.pyx":2293 + * _SymbolTable new_isymbols=None, + * unknown_isymbol=b"", + * bool attach_new_isymbols=True, # <<<<<<<<<<<<<< + * _SymbolTable old_osymbols=None, + * _SymbolTable new_osymbols=None, + */ + bool __pyx_v_attach_new_isymbols = ((bool)1); + + /* "pywrapfst.pyx":2294 + * unknown_isymbol=b"", + * bool attach_new_isymbols=True, + * _SymbolTable old_osymbols=None, # <<<<<<<<<<<<<< + * _SymbolTable new_osymbols=None, + * unknown_osymbol=b"", + */ + struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_old_osymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None); + + /* "pywrapfst.pyx":2295 + * bool attach_new_isymbols=True, + * _SymbolTable old_osymbols=None, + * _SymbolTable new_osymbols=None, # <<<<<<<<<<<<<< + * unknown_osymbol=b"", + * bool attach_new_osymbols=True) except *: + */ + struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_new_osymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None); + PyObject *__pyx_v_unknown_osymbol = ((PyObject *)__pyx_kp_b__24); + + /* "pywrapfst.pyx":2297 + * _SymbolTable new_osymbols=None, + * unknown_osymbol=b"", + * bool attach_new_osymbols=True) except *: # <<<<<<<<<<<<<< + * if new_isymbols is None and new_osymbols is None: + * raise FstArgError("No new SymbolTables specified") + */ + bool __pyx_v_attach_new_osymbols = ((bool)1); + fst::SymbolTable *__pyx_v_new_isymbols_ptr; + fst::SymbolTable *__pyx_v_new_osymbols_ptr; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + fst::SymbolTable *__pyx_t_6; + fst::SymbolTable const *__pyx_t_7; + std::string __pyx_t_8; + fst::SymbolTable const *__pyx_t_9; + std::string __pyx_t_10; + __Pyx_RefNannySetupContext("_relabel_tables", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_old_isymbols = __pyx_optional_args->old_isymbols; + if (__pyx_optional_args->__pyx_n > 1) { + __pyx_v_new_isymbols = __pyx_optional_args->new_isymbols; + if (__pyx_optional_args->__pyx_n > 2) { + __pyx_v_unknown_isymbol = __pyx_optional_args->unknown_isymbol; + if (__pyx_optional_args->__pyx_n > 3) { + __pyx_v_attach_new_isymbols = __pyx_optional_args->attach_new_isymbols; + if (__pyx_optional_args->__pyx_n > 4) { + __pyx_v_old_osymbols = __pyx_optional_args->old_osymbols; + if (__pyx_optional_args->__pyx_n > 5) { + __pyx_v_new_osymbols = __pyx_optional_args->new_osymbols; + if (__pyx_optional_args->__pyx_n > 6) { + __pyx_v_unknown_osymbol = __pyx_optional_args->unknown_osymbol; + if (__pyx_optional_args->__pyx_n > 7) { + __pyx_v_attach_new_osymbols = __pyx_optional_args->attach_new_osymbols; + } + } + } + } + } + } + } + } + } + + /* "pywrapfst.pyx":2298 + * unknown_osymbol=b"", + * bool attach_new_osymbols=True) except *: + * if new_isymbols is None and new_osymbols is None: # <<<<<<<<<<<<<< + * raise FstArgError("No new SymbolTables specified") + * cdef fst.SymbolTable *new_isymbols_ptr = NULL + */ + __pyx_t_2 = (((PyObject *)__pyx_v_new_isymbols) == Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = (((PyObject *)__pyx_v_new_osymbols) == Py_None); + __pyx_t_2 = (__pyx_t_3 != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "pywrapfst.pyx":2299 + * bool attach_new_osymbols=True) except *: + * if new_isymbols is None and new_osymbols is None: + * raise FstArgError("No new SymbolTables specified") # <<<<<<<<<<<<<< + * cdef fst.SymbolTable *new_isymbols_ptr = NULL + * if new_isymbols is not None: + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__44, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 2299, __pyx_L1_error) + + /* "pywrapfst.pyx":2298 + * unknown_osymbol=b"", + * bool attach_new_osymbols=True) except *: + * if new_isymbols is None and new_osymbols is None: # <<<<<<<<<<<<<< + * raise FstArgError("No new SymbolTables specified") + * cdef fst.SymbolTable *new_isymbols_ptr = NULL + */ + } + + /* "pywrapfst.pyx":2300 + * if new_isymbols is None and new_osymbols is None: + * raise FstArgError("No new SymbolTables specified") + * cdef fst.SymbolTable *new_isymbols_ptr = NULL # <<<<<<<<<<<<<< + * if new_isymbols is not None: + * new_isymbols_ptr = new_isymbols._table + */ + __pyx_v_new_isymbols_ptr = NULL; + + /* "pywrapfst.pyx":2301 + * raise FstArgError("No new SymbolTables specified") + * cdef fst.SymbolTable *new_isymbols_ptr = NULL + * if new_isymbols is not None: # <<<<<<<<<<<<<< + * new_isymbols_ptr = new_isymbols._table + * cdef fst.SymbolTable *new_osymbols_ptr = NULL + */ + __pyx_t_1 = (((PyObject *)__pyx_v_new_isymbols) != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "pywrapfst.pyx":2302 + * cdef fst.SymbolTable *new_isymbols_ptr = NULL + * if new_isymbols is not None: + * new_isymbols_ptr = new_isymbols._table # <<<<<<<<<<<<<< + * cdef fst.SymbolTable *new_osymbols_ptr = NULL + * if new_osymbols is not None: + */ + if (unlikely(((PyObject *)__pyx_v_new_isymbols) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 2302, __pyx_L1_error) + } + __pyx_t_6 = __pyx_v_new_isymbols->_table; + __pyx_v_new_isymbols_ptr = __pyx_t_6; + + /* "pywrapfst.pyx":2301 + * raise FstArgError("No new SymbolTables specified") + * cdef fst.SymbolTable *new_isymbols_ptr = NULL + * if new_isymbols is not None: # <<<<<<<<<<<<<< + * new_isymbols_ptr = new_isymbols._table + * cdef fst.SymbolTable *new_osymbols_ptr = NULL + */ + } + + /* "pywrapfst.pyx":2303 + * if new_isymbols is not None: + * new_isymbols_ptr = new_isymbols._table + * cdef fst.SymbolTable *new_osymbols_ptr = NULL # <<<<<<<<<<<<<< + * if new_osymbols is not None: + * new_osymbols_ptr = new_osymbols._table + */ + __pyx_v_new_osymbols_ptr = NULL; + + /* "pywrapfst.pyx":2304 + * new_isymbols_ptr = new_isymbols._table + * cdef fst.SymbolTable *new_osymbols_ptr = NULL + * if new_osymbols is not None: # <<<<<<<<<<<<<< + * new_osymbols_ptr = new_osymbols._table + * fst.Relabel(self._mfst.get(), + */ + __pyx_t_2 = (((PyObject *)__pyx_v_new_osymbols) != Py_None); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":2305 + * cdef fst.SymbolTable *new_osymbols_ptr = NULL + * if new_osymbols is not None: + * new_osymbols_ptr = new_osymbols._table # <<<<<<<<<<<<<< + * fst.Relabel(self._mfst.get(), + * self._fst.get().InputSymbols() if old_isymbols is None else + */ + if (unlikely(((PyObject *)__pyx_v_new_osymbols) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 2305, __pyx_L1_error) + } + __pyx_t_6 = __pyx_v_new_osymbols->_table; + __pyx_v_new_osymbols_ptr = __pyx_t_6; + + /* "pywrapfst.pyx":2304 + * new_isymbols_ptr = new_isymbols._table + * cdef fst.SymbolTable *new_osymbols_ptr = NULL + * if new_osymbols is not None: # <<<<<<<<<<<<<< + * new_osymbols_ptr = new_osymbols._table + * fst.Relabel(self._mfst.get(), + */ + } + + /* "pywrapfst.pyx":2306 + * if new_osymbols is not None: + * new_osymbols_ptr = new_osymbols._table + * fst.Relabel(self._mfst.get(), # <<<<<<<<<<<<<< + * self._fst.get().InputSymbols() if old_isymbols is None else + * old_isymbols._table, new_isymbols_ptr, tostring(unknown_isymbol), + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2306, __pyx_L1_error) + } + + /* "pywrapfst.pyx":2307 + * new_osymbols_ptr = new_osymbols._table + * fst.Relabel(self._mfst.get(), + * self._fst.get().InputSymbols() if old_isymbols is None else # <<<<<<<<<<<<<< + * old_isymbols._table, new_isymbols_ptr, tostring(unknown_isymbol), + * attach_new_isymbols, + */ + __pyx_t_1 = (((PyObject *)__pyx_v_old_isymbols) == Py_None); + if ((__pyx_t_1 != 0)) { + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 2307, __pyx_L1_error) + } + __pyx_t_7 = __pyx_v_self->__pyx_base._fst.get()->InputSymbols(); + } else { + + /* "pywrapfst.pyx":2308 + * fst.Relabel(self._mfst.get(), + * self._fst.get().InputSymbols() if old_isymbols is None else + * old_isymbols._table, new_isymbols_ptr, tostring(unknown_isymbol), # <<<<<<<<<<<<<< + * attach_new_isymbols, + * self._fst.get().OutputSymbols() if old_osymbols is None else + */ + if (unlikely(((PyObject *)__pyx_v_old_isymbols) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 2308, __pyx_L1_error) + } + __pyx_t_7 = __pyx_v_old_isymbols->_table; + } + __pyx_t_8 = __pyx_f_9pywrapfst_tostring(__pyx_v_unknown_isymbol, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2308, __pyx_L1_error) + + /* "pywrapfst.pyx":2310 + * old_isymbols._table, new_isymbols_ptr, tostring(unknown_isymbol), + * attach_new_isymbols, + * self._fst.get().OutputSymbols() if old_osymbols is None else # <<<<<<<<<<<<<< + * old_osymbols._table, new_osymbols_ptr, tostring(unknown_osymbol), + * attach_new_osymbols) + */ + __pyx_t_1 = (((PyObject *)__pyx_v_old_osymbols) == Py_None); + if ((__pyx_t_1 != 0)) { + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 2310, __pyx_L1_error) + } + __pyx_t_9 = __pyx_v_self->__pyx_base._fst.get()->OutputSymbols(); + } else { + + /* "pywrapfst.pyx":2311 + * attach_new_isymbols, + * self._fst.get().OutputSymbols() if old_osymbols is None else + * old_osymbols._table, new_osymbols_ptr, tostring(unknown_osymbol), # <<<<<<<<<<<<<< + * attach_new_osymbols) + * self._check_mutating_imethod() + */ + if (unlikely(((PyObject *)__pyx_v_old_osymbols) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 2311, __pyx_L1_error) + } + __pyx_t_9 = __pyx_v_old_osymbols->_table; + } + __pyx_t_10 = __pyx_f_9pywrapfst_tostring(__pyx_v_unknown_osymbol, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2311, __pyx_L1_error) + + /* "pywrapfst.pyx":2306 + * if new_osymbols is not None: + * new_osymbols_ptr = new_osymbols._table + * fst.Relabel(self._mfst.get(), # <<<<<<<<<<<<<< + * self._fst.get().InputSymbols() if old_isymbols is None else + * old_isymbols._table, new_isymbols_ptr, tostring(unknown_isymbol), + */ + fst::script::Relabel(__pyx_v_self->_mfst.get(), __pyx_t_7, __pyx_v_new_isymbols_ptr, __pyx_t_8, __pyx_v_attach_new_isymbols, __pyx_t_9, __pyx_v_new_osymbols_ptr, __pyx_t_10, __pyx_v_attach_new_osymbols); + + /* "pywrapfst.pyx":2313 + * old_osymbols._table, new_osymbols_ptr, tostring(unknown_osymbol), + * attach_new_osymbols) + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def relabel_tables(self, + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 2313, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2313, __pyx_L1_error) + + /* "pywrapfst.pyx":2289 + * return self + * + * cdef void _relabel_tables(self, # <<<<<<<<<<<<<< + * _SymbolTable old_isymbols=None, + * _SymbolTable new_isymbols=None, + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pywrapfst._MutableFst._relabel_tables", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":2315 + * self._check_mutating_imethod() + * + * def relabel_tables(self, # <<<<<<<<<<<<<< + * _SymbolTable old_isymbols=None, + * _SymbolTable new_isymbols=None, + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_41relabel_tables(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_40relabel_tables[] = "\n relabel_tables(self, old_isymbols=None, new_isymbols=None,\n unknown_isymbol=\"\", attach_new_isymbols=True,\n old_osymbols=None, new_osymbols=None,\n unknown_osymbol=\"\", attach_new_osymbols=True)\n\n Replaces input and/or output labels using SymbolTables.\n\n This operation destructively relabels the input and/or output labels of the\n FST using user-specified symbol tables; omitted symbols are identity-mapped.\n\n Args:\n old_isymbols: The old SymbolTable for input labels, defaulting to the\n FST's input symbol table.\n new_isymbols: A SymbolTable used to relabel the input labels\n unknown_isymbol: Input symbol to use to relabel OOVs (if empty,\n OOVs raise an exception)\n attach_new_isymbols: Should new_isymbols be made the FST's input symbol\n table?\n old_osymbols: The old SymbolTable for output labels, defaulting to the\n FST's output symbol table.\n new_osymbols: A SymbolTable used to relabel the output labels.\n unknown_osymbol: Outnput symbol to use to relabel OOVs (if empty,\n OOVs raise an exception)\n attach_new_isymbols: Should new_osymbols be made the FST's output symbol\n table?\n\n Returns:\n self.\n\n Raises:\n FstArgError: No SymbolTable specified.\n\n See also: `decode`, `encode`, `project`, `relabel_pairs`.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_41relabel_tables(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_old_isymbols = 0; + struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_new_isymbols = 0; + PyObject *__pyx_v_unknown_isymbol = 0; + bool __pyx_v_attach_new_isymbols; + struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_old_osymbols = 0; + struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_new_osymbols = 0; + PyObject *__pyx_v_unknown_osymbol = 0; + bool __pyx_v_attach_new_osymbols; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("relabel_tables (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_old_isymbols,&__pyx_n_s_new_isymbols,&__pyx_n_s_unknown_isymbol,&__pyx_n_s_attach_new_isymbols,&__pyx_n_s_old_osymbols,&__pyx_n_s_new_osymbols,&__pyx_n_s_unknown_osymbol,&__pyx_n_s_attach_new_osymbols,0}; + PyObject* values[8] = {0,0,0,0,0,0,0,0}; + + /* "pywrapfst.pyx":2316 + * + * def relabel_tables(self, + * _SymbolTable old_isymbols=None, # <<<<<<<<<<<<<< + * _SymbolTable new_isymbols=None, + * unknown_isymbol=b"", + */ + values[0] = (PyObject *)((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None); + + /* "pywrapfst.pyx":2317 + * def relabel_tables(self, + * _SymbolTable old_isymbols=None, + * _SymbolTable new_isymbols=None, # <<<<<<<<<<<<<< + * unknown_isymbol=b"", + * bool attach_new_isymbols=True, + */ + values[1] = (PyObject *)((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None); + values[2] = ((PyObject *)__pyx_kp_b__24); + + /* "pywrapfst.pyx":2320 + * unknown_isymbol=b"", + * bool attach_new_isymbols=True, + * _SymbolTable old_osymbols=None, # <<<<<<<<<<<<<< + * _SymbolTable new_osymbols=None, + * unknown_osymbol=b"", + */ + values[4] = (PyObject *)((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None); + + /* "pywrapfst.pyx":2321 + * bool attach_new_isymbols=True, + * _SymbolTable old_osymbols=None, + * _SymbolTable new_osymbols=None, # <<<<<<<<<<<<<< + * unknown_osymbol=b"", + * bool attach_new_osymbols=True): + */ + values[5] = (PyObject *)((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None); + values[6] = ((PyObject *)__pyx_kp_b__24); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_old_isymbols); + if (value) { values[0] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_new_isymbols); + if (value) { values[1] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_unknown_isymbol); + if (value) { values[2] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_attach_new_isymbols); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_old_osymbols); + if (value) { values[4] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_new_osymbols); + if (value) { values[5] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_unknown_osymbol); + if (value) { values[6] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_attach_new_osymbols); + if (value) { values[7] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "relabel_tables") < 0)) __PYX_ERR(0, 2315, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_old_isymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[0]); + __pyx_v_new_isymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[1]); + __pyx_v_unknown_isymbol = values[2]; + if (values[3]) { + __pyx_v_attach_new_isymbols = __Pyx_PyObject_IsTrue(values[3]); if (unlikely((__pyx_v_attach_new_isymbols == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2319, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":2319 + * _SymbolTable new_isymbols=None, + * unknown_isymbol=b"", + * bool attach_new_isymbols=True, # <<<<<<<<<<<<<< + * _SymbolTable old_osymbols=None, + * _SymbolTable new_osymbols=None, + */ + __pyx_v_attach_new_isymbols = ((bool)1); + } + __pyx_v_old_osymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[4]); + __pyx_v_new_osymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[5]); + __pyx_v_unknown_osymbol = values[6]; + if (values[7]) { + __pyx_v_attach_new_osymbols = __Pyx_PyObject_IsTrue(values[7]); if (unlikely((__pyx_v_attach_new_osymbols == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2323, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":2323 + * _SymbolTable new_osymbols=None, + * unknown_osymbol=b"", + * bool attach_new_osymbols=True): # <<<<<<<<<<<<<< + * """ + * relabel_tables(self, old_isymbols=None, new_isymbols=None, + */ + __pyx_v_attach_new_osymbols = ((bool)1); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("relabel_tables", 0, 0, 8, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2315, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.relabel_tables", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_old_isymbols), __pyx_ptype_9pywrapfst__SymbolTable, 1, "old_isymbols", 0))) __PYX_ERR(0, 2316, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_new_isymbols), __pyx_ptype_9pywrapfst__SymbolTable, 1, "new_isymbols", 0))) __PYX_ERR(0, 2317, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_old_osymbols), __pyx_ptype_9pywrapfst__SymbolTable, 1, "old_osymbols", 0))) __PYX_ERR(0, 2320, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_new_osymbols), __pyx_ptype_9pywrapfst__SymbolTable, 1, "new_osymbols", 0))) __PYX_ERR(0, 2321, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_40relabel_tables(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_old_isymbols, __pyx_v_new_isymbols, __pyx_v_unknown_isymbol, __pyx_v_attach_new_isymbols, __pyx_v_old_osymbols, __pyx_v_new_osymbols, __pyx_v_unknown_osymbol, __pyx_v_attach_new_osymbols); + + /* "pywrapfst.pyx":2315 + * self._check_mutating_imethod() + * + * def relabel_tables(self, # <<<<<<<<<<<<<< + * _SymbolTable old_isymbols=None, + * _SymbolTable new_isymbols=None, + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_40relabel_tables(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_old_isymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_new_isymbols, PyObject *__pyx_v_unknown_isymbol, bool __pyx_v_attach_new_isymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_old_osymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_new_osymbols, PyObject *__pyx_v_unknown_osymbol, bool __pyx_v_attach_new_osymbols) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_tables __pyx_t_1; + __Pyx_RefNannySetupContext("relabel_tables", 0); + + /* "pywrapfst.pyx":2359 + * See also: `decode`, `encode`, `project`, `relabel_pairs`. + * """ + * self._relabel_tables(old_isymbols, new_isymbols, # <<<<<<<<<<<<<< + * unknown_isymbol, attach_new_isymbols, + * old_osymbols, new_osymbols, + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_relabel_tables"); + __PYX_ERR(0, 2359, __pyx_L1_error) + } + + /* "pywrapfst.pyx":2362 + * unknown_isymbol, attach_new_isymbols, + * old_osymbols, new_osymbols, + * unknown_osymbol, attach_new_osymbols) # <<<<<<<<<<<<<< + * return self + * + */ + __pyx_t_1.__pyx_n = 8; + __pyx_t_1.old_isymbols = __pyx_v_old_isymbols; + __pyx_t_1.new_isymbols = __pyx_v_new_isymbols; + __pyx_t_1.unknown_isymbol = __pyx_v_unknown_isymbol; + __pyx_t_1.attach_new_isymbols = __pyx_v_attach_new_isymbols; + __pyx_t_1.old_osymbols = __pyx_v_old_osymbols; + __pyx_t_1.new_osymbols = __pyx_v_new_osymbols; + __pyx_t_1.unknown_osymbol = __pyx_v_unknown_osymbol; + __pyx_t_1.attach_new_osymbols = __pyx_v_attach_new_osymbols; + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_relabel_tables(__pyx_v_self, &__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2359, __pyx_L1_error) + + /* "pywrapfst.pyx":2363 + * old_osymbols, new_osymbols, + * unknown_osymbol, attach_new_osymbols) + * return self # <<<<<<<<<<<<<< + * + * cdef void _reserve_arcs(self, int64 state, size_t n) except *: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":2315 + * self._check_mutating_imethod() + * + * def relabel_tables(self, # <<<<<<<<<<<<<< + * _SymbolTable old_isymbols=None, + * _SymbolTable new_isymbols=None, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.relabel_tables", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2365 + * return self + * + * cdef void _reserve_arcs(self, int64 state, size_t n) except *: # <<<<<<<<<<<<<< + * if not self._mfst.get().ReserveArcs(state, n): + * raise FstIndexError("State index out of range") + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__reserve_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, size_t __pyx_v_n) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("_reserve_arcs", 0); + + /* "pywrapfst.pyx":2366 + * + * cdef void _reserve_arcs(self, int64 state, size_t n) except *: + * if not self._mfst.get().ReserveArcs(state, n): # <<<<<<<<<<<<<< + * raise FstIndexError("State index out of range") + * self._check_mutating_imethod() + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2366, __pyx_L1_error) + } + __pyx_t_1 = ((!(__pyx_v_self->_mfst.get()->ReserveArcs(__pyx_v_state, __pyx_v_n) != 0)) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":2367 + * cdef void _reserve_arcs(self, int64 state, size_t n) except *: + * if not self._mfst.get().ReserveArcs(state, n): + * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__45, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 2367, __pyx_L1_error) + + /* "pywrapfst.pyx":2366 + * + * cdef void _reserve_arcs(self, int64 state, size_t n) except *: + * if not self._mfst.get().ReserveArcs(state, n): # <<<<<<<<<<<<<< + * raise FstIndexError("State index out of range") + * self._check_mutating_imethod() + */ + } + + /* "pywrapfst.pyx":2368 + * if not self._mfst.get().ReserveArcs(state, n): + * raise FstIndexError("State index out of range") + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def reserve_arcs(self, int64 state, size_t n): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 2368, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2368, __pyx_L1_error) + + /* "pywrapfst.pyx":2365 + * return self + * + * cdef void _reserve_arcs(self, int64 state, size_t n) except *: # <<<<<<<<<<<<<< + * if not self._mfst.get().ReserveArcs(state, n): + * raise FstIndexError("State index out of range") + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pywrapfst._MutableFst._reserve_arcs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":2370 + * self._check_mutating_imethod() + * + * def reserve_arcs(self, int64 state, size_t n): # <<<<<<<<<<<<<< + * """ + * reserve_arcs(self, state, n) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_43reserve_arcs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_42reserve_arcs[] = "\n reserve_arcs(self, state, n)\n\n Reserve n arcs at a particular state (best effort).\n\n Args:\n state: The integer index of a state.\n n: The number of arcs to reserve.\n\n Returns:\n self.\n\n Raises:\n FstIndexError: State index out of range.\n\n See also: `reserve_states`.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_43reserve_arcs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + __pyx_t_10basictypes_int64 __pyx_v_state; + size_t __pyx_v_n; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("reserve_arcs (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_state,&__pyx_n_s_n,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_n)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("reserve_arcs", 1, 2, 2, 1); __PYX_ERR(0, 2370, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "reserve_arcs") < 0)) __PYX_ERR(0, 2370, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_state = __Pyx_PyInt_As_int64_t(values[0]); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2370, __pyx_L3_error) + __pyx_v_n = __Pyx_PyInt_As_size_t(values[1]); if (unlikely((__pyx_v_n == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2370, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("reserve_arcs", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2370, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.reserve_arcs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_42reserve_arcs(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_state, __pyx_v_n); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_42reserve_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, size_t __pyx_v_n) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("reserve_arcs", 0); + + /* "pywrapfst.pyx":2388 + * See also: `reserve_states`. + * """ + * self._reserve_arcs(state, n) # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_reserve_arcs"); + __PYX_ERR(0, 2388, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_reserve_arcs(__pyx_v_self, __pyx_v_state, __pyx_v_n); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2388, __pyx_L1_error) + + /* "pywrapfst.pyx":2389 + * """ + * self._reserve_arcs(state, n) + * return self # <<<<<<<<<<<<<< + * + * cdef void _reserve_states(self, int64 n) except *: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":2370 + * self._check_mutating_imethod() + * + * def reserve_arcs(self, int64 state, size_t n): # <<<<<<<<<<<<<< + * """ + * reserve_arcs(self, state, n) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.reserve_arcs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2391 + * return self + * + * cdef void _reserve_states(self, int64 n) except *: # <<<<<<<<<<<<<< + * self._mfst.get().ReserveStates(n) + * self._check_mutating_imethod() + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__reserve_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_n) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_reserve_states", 0); + + /* "pywrapfst.pyx":2392 + * + * cdef void _reserve_states(self, int64 n) except *: + * self._mfst.get().ReserveStates(n) # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2392, __pyx_L1_error) + } + __pyx_v_self->_mfst.get()->ReserveStates(__pyx_v_n); + + /* "pywrapfst.pyx":2393 + * cdef void _reserve_states(self, int64 n) except *: + * self._mfst.get().ReserveStates(n) + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def reserve_states(self, int64 n): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 2393, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2393, __pyx_L1_error) + + /* "pywrapfst.pyx":2391 + * return self + * + * cdef void _reserve_states(self, int64 n) except *: # <<<<<<<<<<<<<< + * self._mfst.get().ReserveStates(n) + * self._check_mutating_imethod() + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst._reserve_states", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":2395 + * self._check_mutating_imethod() + * + * def reserve_states(self, int64 n): # <<<<<<<<<<<<<< + * """ + * reserve_states(self, n) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_45reserve_states(PyObject *__pyx_v_self, PyObject *__pyx_arg_n); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_44reserve_states[] = "\n reserve_states(self, n)\n\n Reserve n states (best effort).\n\n Args:\n n: The number of states to reserve.\n\n Returns:\n self.\n\n See also: `reserve_arcs`.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_45reserve_states(PyObject *__pyx_v_self, PyObject *__pyx_arg_n) { + __pyx_t_10basictypes_int64 __pyx_v_n; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("reserve_states (wrapper)", 0); + assert(__pyx_arg_n); { + __pyx_v_n = __Pyx_PyInt_As_int64_t(__pyx_arg_n); if (unlikely((__pyx_v_n == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2395, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.reserve_states", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_44reserve_states(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), ((__pyx_t_10basictypes_int64)__pyx_v_n)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_44reserve_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_n) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("reserve_states", 0); + + /* "pywrapfst.pyx":2409 + * See also: `reserve_arcs`. + * """ + * self._reserve_states(n) # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_reserve_states"); + __PYX_ERR(0, 2409, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_reserve_states(__pyx_v_self, __pyx_v_n); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2409, __pyx_L1_error) + + /* "pywrapfst.pyx":2410 + * """ + * self._reserve_states(n) + * return self # <<<<<<<<<<<<<< + * + * cdef void _reweight(self, potentials, bool to_final=False) except *: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":2395 + * self._check_mutating_imethod() + * + * def reserve_states(self, int64 n): # <<<<<<<<<<<<<< + * """ + * reserve_states(self, n) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.reserve_states", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2412 + * return self + * + * cdef void _reweight(self, potentials, bool to_final=False) except *: # <<<<<<<<<<<<<< + * cdef unique_ptr[vector[fst.WeightClass]] _potentials + * _potentials.reset(new vector[fst.WeightClass]()) + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__reweight(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, PyObject *__pyx_v_potentials, struct __pyx_opt_args_9pywrapfst_11_MutableFst__reweight *__pyx_optional_args) { + bool __pyx_v_to_final = ((bool)0); + std::unique_ptr > __pyx_v__potentials; + CYTHON_UNUSED std::string __pyx_v_weight_type; + PyObject *__pyx_v_weight = NULL; + __Pyx_RefNannyDeclarations + std::vector *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *(*__pyx_t_4)(PyObject *); + PyObject *__pyx_t_5 = NULL; + fst::script::WeightClass __pyx_t_6; + __Pyx_RefNannySetupContext("_reweight", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_to_final = __pyx_optional_args->to_final; + } + } + + /* "pywrapfst.pyx":2414 + * cdef void _reweight(self, potentials, bool to_final=False) except *: + * cdef unique_ptr[vector[fst.WeightClass]] _potentials + * _potentials.reset(new vector[fst.WeightClass]()) # <<<<<<<<<<<<<< + * cdef string weight_type = self.weight_type() + * for weight in potentials: + */ + try { + __pyx_t_1 = new std::vector (); + } catch(...) { + __Pyx_CppExn2PyErr(); + __PYX_ERR(0, 2414, __pyx_L1_error) + } + __pyx_v__potentials.reset(__pyx_t_1); + + /* "pywrapfst.pyx":2415 + * cdef unique_ptr[vector[fst.WeightClass]] _potentials + * _potentials.reset(new vector[fst.WeightClass]()) + * cdef string weight_type = self.weight_type() # <<<<<<<<<<<<<< + * for weight in potentials: + * _potentials.get().push_back(_get_WeightClass_or_One(self.weight_type(), + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "weight_type"); + __PYX_ERR(0, 2415, __pyx_L1_error) + } + __pyx_v_weight_type = ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.weight_type(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), 0); + + /* "pywrapfst.pyx":2416 + * _potentials.reset(new vector[fst.WeightClass]()) + * cdef string weight_type = self.weight_type() + * for weight in potentials: # <<<<<<<<<<<<<< + * _potentials.get().push_back(_get_WeightClass_or_One(self.weight_type(), + * weight)) + */ + if (likely(PyList_CheckExact(__pyx_v_potentials)) || PyTuple_CheckExact(__pyx_v_potentials)) { + __pyx_t_2 = __pyx_v_potentials; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_potentials); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2416, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 2416, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } else { + if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 2416, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } + } else { + __pyx_t_5 = __pyx_t_4(__pyx_t_2); + if (unlikely(!__pyx_t_5)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 2416, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_XDECREF_SET(__pyx_v_weight, __pyx_t_5); + __pyx_t_5 = 0; + + /* "pywrapfst.pyx":2417 + * cdef string weight_type = self.weight_type() + * for weight in potentials: + * _potentials.get().push_back(_get_WeightClass_or_One(self.weight_type(), # <<<<<<<<<<<<<< + * weight)) + * fst.Reweight(self._mfst.get(), deref(_potentials), + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "weight_type"); + __PYX_ERR(0, 2417, __pyx_L1_error) + } + + /* "pywrapfst.pyx":2418 + * for weight in potentials: + * _potentials.get().push_back(_get_WeightClass_or_One(self.weight_type(), + * weight)) # <<<<<<<<<<<<<< + * fst.Reweight(self._mfst.get(), deref(_potentials), + * fst.GetReweightType(to_final)) + */ + __pyx_t_6 = __pyx_f_9pywrapfst__get_WeightClass_or_One(((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.weight_type(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), 0), __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2417, __pyx_L1_error) + + /* "pywrapfst.pyx":2417 + * cdef string weight_type = self.weight_type() + * for weight in potentials: + * _potentials.get().push_back(_get_WeightClass_or_One(self.weight_type(), # <<<<<<<<<<<<<< + * weight)) + * fst.Reweight(self._mfst.get(), deref(_potentials), + */ + try { + __pyx_v__potentials.get()->push_back(__pyx_t_6); + } catch(...) { + __Pyx_CppExn2PyErr(); + __PYX_ERR(0, 2417, __pyx_L1_error) + } + + /* "pywrapfst.pyx":2416 + * _potentials.reset(new vector[fst.WeightClass]()) + * cdef string weight_type = self.weight_type() + * for weight in potentials: # <<<<<<<<<<<<<< + * _potentials.get().push_back(_get_WeightClass_or_One(self.weight_type(), + * weight)) + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "pywrapfst.pyx":2419 + * _potentials.get().push_back(_get_WeightClass_or_One(self.weight_type(), + * weight)) + * fst.Reweight(self._mfst.get(), deref(_potentials), # <<<<<<<<<<<<<< + * fst.GetReweightType(to_final)) + * self._check_mutating_imethod() + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2419, __pyx_L1_error) + } + + /* "pywrapfst.pyx":2420 + * weight)) + * fst.Reweight(self._mfst.get(), deref(_potentials), + * fst.GetReweightType(to_final)) # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + fst::script::Reweight(__pyx_v_self->_mfst.get(), (*__pyx_v__potentials), fst::script::GetReweightType(__pyx_v_to_final)); + + /* "pywrapfst.pyx":2421 + * fst.Reweight(self._mfst.get(), deref(_potentials), + * fst.GetReweightType(to_final)) + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def reweight(self, potentials, bool to_final=False): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 2421, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2421, __pyx_L1_error) + + /* "pywrapfst.pyx":2412 + * return self + * + * cdef void _reweight(self, potentials, bool to_final=False) except *: # <<<<<<<<<<<<<< + * cdef unique_ptr[vector[fst.WeightClass]] _potentials + * _potentials.reset(new vector[fst.WeightClass]()) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pywrapfst._MutableFst._reweight", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_weight); + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":2423 + * self._check_mutating_imethod() + * + * def reweight(self, potentials, bool to_final=False): # <<<<<<<<<<<<<< + * """ + * reweight(self, potentials, to_final=False) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_47reweight(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_46reweight[] = "\n reweight(self, potentials, to_final=False)\n\n Reweights an FST using an iterable of potentials.\n\n This operation destructively reweights an FST according to the potentials\n and in the direction specified by the user. An arc of weight w, with an\n origin state of potential p and destination state of potential q, is\n reweighted by p^{-1} \\otimes (w \\otimes q) when reweighting towards the\n initial state, and by (p \\otimes w) \\otimes q^{-1} when reweighting towards\n the final states. The weights must be left distributive when reweighting\n towards the initial state and right distributive when reweighting towards\n the final states (e.g., TropicalWeight and LogWeight).\n\n Args:\n potentials: An iterable of Weight or weight strings.\n to_final: Push towards final states?\n\n Returns:\n self.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_47reweight(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_potentials = 0; + bool __pyx_v_to_final; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("reweight (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_potentials,&__pyx_n_s_to_final,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_potentials)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_to_final); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "reweight") < 0)) __PYX_ERR(0, 2423, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_potentials = values[0]; + if (values[1]) { + __pyx_v_to_final = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_to_final == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2423, __pyx_L3_error) + } else { + __pyx_v_to_final = ((bool)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("reweight", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2423, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.reweight", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_46reweight(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_potentials, __pyx_v_to_final); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_46reweight(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, PyObject *__pyx_v_potentials, bool __pyx_v_to_final) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + struct __pyx_opt_args_9pywrapfst_11_MutableFst__reweight __pyx_t_1; + __Pyx_RefNannySetupContext("reweight", 0); + + /* "pywrapfst.pyx":2445 + * self. + * """ + * self._reweight(potentials, to_final) # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_reweight"); + __PYX_ERR(0, 2445, __pyx_L1_error) + } + __pyx_t_1.__pyx_n = 1; + __pyx_t_1.to_final = __pyx_v_to_final; + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_reweight(__pyx_v_self, __pyx_v_potentials, &__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2445, __pyx_L1_error) + + /* "pywrapfst.pyx":2446 + * """ + * self._reweight(potentials, to_final) + * return self # <<<<<<<<<<<<<< + * + * cdef void _rmepsilon(self, + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":2423 + * self._check_mutating_imethod() + * + * def reweight(self, potentials, bool to_final=False): # <<<<<<<<<<<<<< + * """ + * reweight(self, potentials, to_final=False) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.reweight", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2448 + * return self + * + * cdef void _rmepsilon(self, # <<<<<<<<<<<<<< + * queue_type=b"auto", + * bool connect=True, + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__rmepsilon(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__rmepsilon *__pyx_optional_args) { + PyObject *__pyx_v_queue_type = ((PyObject *)__pyx_n_b_auto); + + /* "pywrapfst.pyx":2450 + * cdef void _rmepsilon(self, + * queue_type=b"auto", + * bool connect=True, # <<<<<<<<<<<<<< + * weight=None, + * int64 nstate=fst.kNoStateId, + */ + bool __pyx_v_connect = ((bool)1); + + /* "pywrapfst.pyx":2451 + * queue_type=b"auto", + * bool connect=True, + * weight=None, # <<<<<<<<<<<<<< + * int64 nstate=fst.kNoStateId, + * float delta=fst.kShortestDelta) except *: + */ + PyObject *__pyx_v_weight = ((PyObject *)Py_None); + __pyx_t_10basictypes_int64 __pyx_v_nstate = __pyx_k__46; + float __pyx_v_delta = __pyx_k__47; + fst::script::WeightClass __pyx_v_wc; + std::unique_ptr __pyx_v_opts; + __Pyx_RefNannyDeclarations + fst::script::WeightClass __pyx_t_1; + std::string __pyx_t_2; + enum fst::QueueType __pyx_t_3; + __Pyx_RefNannySetupContext("_rmepsilon", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_queue_type = __pyx_optional_args->queue_type; + if (__pyx_optional_args->__pyx_n > 1) { + __pyx_v_connect = __pyx_optional_args->connect; + if (__pyx_optional_args->__pyx_n > 2) { + __pyx_v_weight = __pyx_optional_args->weight; + if (__pyx_optional_args->__pyx_n > 3) { + __pyx_v_nstate = __pyx_optional_args->nstate; + if (__pyx_optional_args->__pyx_n > 4) { + __pyx_v_delta = __pyx_optional_args->delta; + } + } + } + } + } + } + + /* "pywrapfst.pyx":2454 + * int64 nstate=fst.kNoStateId, + * float delta=fst.kShortestDelta) except *: + * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(self.weight_type(), # <<<<<<<<<<<<<< + * weight) + * cdef unique_ptr[fst.RmEpsilonOptions] opts + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "weight_type"); + __PYX_ERR(0, 2454, __pyx_L1_error) + } + + /* "pywrapfst.pyx":2455 + * float delta=fst.kShortestDelta) except *: + * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(self.weight_type(), + * weight) # <<<<<<<<<<<<<< + * cdef unique_ptr[fst.RmEpsilonOptions] opts + * opts.reset(new fst.RmEpsilonOptions(_get_queue_type(tostring(queue_type)), + */ + __pyx_t_1 = __pyx_f_9pywrapfst__get_WeightClass_or_Zero(((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.weight_type(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), 0), __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2454, __pyx_L1_error) + __pyx_v_wc = __pyx_t_1; + + /* "pywrapfst.pyx":2457 + * weight) + * cdef unique_ptr[fst.RmEpsilonOptions] opts + * opts.reset(new fst.RmEpsilonOptions(_get_queue_type(tostring(queue_type)), # <<<<<<<<<<<<<< + * connect, wc, nstate, delta)) + * fst.RmEpsilon(self._mfst.get(), deref(opts)) + */ + __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_v_queue_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2457, __pyx_L1_error) + __pyx_t_3 = __pyx_f_9pywrapfst__get_queue_type(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2457, __pyx_L1_error) + + /* "pywrapfst.pyx":2458 + * cdef unique_ptr[fst.RmEpsilonOptions] opts + * opts.reset(new fst.RmEpsilonOptions(_get_queue_type(tostring(queue_type)), + * connect, wc, nstate, delta)) # <<<<<<<<<<<<<< + * fst.RmEpsilon(self._mfst.get(), deref(opts)) + * self._check_mutating_imethod() + */ + __pyx_v_opts.reset(new fst::script::RmEpsilonOptions(__pyx_t_3, __pyx_v_connect, __pyx_v_wc, __pyx_v_nstate, __pyx_v_delta)); + + /* "pywrapfst.pyx":2459 + * opts.reset(new fst.RmEpsilonOptions(_get_queue_type(tostring(queue_type)), + * connect, wc, nstate, delta)) + * fst.RmEpsilon(self._mfst.get(), deref(opts)) # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2459, __pyx_L1_error) + } + fst::script::RmEpsilon(__pyx_v_self->_mfst.get(), (*__pyx_v_opts)); + + /* "pywrapfst.pyx":2460 + * connect, wc, nstate, delta)) + * fst.RmEpsilon(self._mfst.get(), deref(opts)) + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def rmepsilon(self, + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 2460, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2460, __pyx_L1_error) + + /* "pywrapfst.pyx":2448 + * return self + * + * cdef void _rmepsilon(self, # <<<<<<<<<<<<<< + * queue_type=b"auto", + * bool connect=True, + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst._rmepsilon", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":2462 + * self._check_mutating_imethod() + * + * def rmepsilon(self, # <<<<<<<<<<<<<< + * queue_type=b"auto", + * bool connect=True, + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_49rmepsilon(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_48rmepsilon[] = "\n rmepsilon(self, queue_type=\"auto\", connect=True, weight=None,\n nstate=NO_STATE_ID, delta=1e-6):\n\n Removes epsilon transitions.\n\n This operation destructively removes epsilon transitions, i.e., those where\n both input and output labels are epsilon) from an FST.\n\n Args:\n queue_type: A string matching a known queue type; one of: \"auto\", \"fifo\",\n \"lifo\", \"shortest\", \"state\", \"top\".\n connect: Should output be trimmed?\n weight: A Weight or weight string indicating the desired weight threshold\n below which paths are pruned; if omitted, no paths are pruned.\n nstate: State number threshold.\n delta: Comparison/quantization delta.\n\n Returns:\n self.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_49rmepsilon(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_queue_type = 0; + bool __pyx_v_connect; + PyObject *__pyx_v_weight = 0; + __pyx_t_10basictypes_int64 __pyx_v_nstate; + float __pyx_v_delta; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("rmepsilon (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_queue_type,&__pyx_n_s_connect,&__pyx_n_s_weight,&__pyx_n_s_nstate,&__pyx_n_s_delta,0}; + PyObject* values[5] = {0,0,0,0,0}; + values[0] = ((PyObject *)__pyx_n_b_auto); + + /* "pywrapfst.pyx":2465 + * queue_type=b"auto", + * bool connect=True, + * weight=None, # <<<<<<<<<<<<<< + * int64 nstate=fst.kNoStateId, + * float delta=fst.kShortestDelta): + */ + values[2] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_queue_type); + if (value) { values[0] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_connect); + if (value) { values[1] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weight); + if (value) { values[2] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nstate); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "rmepsilon") < 0)) __PYX_ERR(0, 2462, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_queue_type = values[0]; + if (values[1]) { + __pyx_v_connect = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_connect == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2464, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":2464 + * def rmepsilon(self, + * queue_type=b"auto", + * bool connect=True, # <<<<<<<<<<<<<< + * weight=None, + * int64 nstate=fst.kNoStateId, + */ + __pyx_v_connect = ((bool)1); + } + __pyx_v_weight = values[2]; + if (values[3]) { + __pyx_v_nstate = __Pyx_PyInt_As_int64_t(values[3]); if (unlikely((__pyx_v_nstate == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2466, __pyx_L3_error) + } else { + __pyx_v_nstate = __pyx_k__48; + } + if (values[4]) { + __pyx_v_delta = __pyx_PyFloat_AsFloat(values[4]); if (unlikely((__pyx_v_delta == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2467, __pyx_L3_error) + } else { + __pyx_v_delta = __pyx_k__49; + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("rmepsilon", 0, 0, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2462, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.rmepsilon", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_48rmepsilon(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_queue_type, __pyx_v_connect, __pyx_v_weight, __pyx_v_nstate, __pyx_v_delta); + + /* "pywrapfst.pyx":2462 + * self._check_mutating_imethod() + * + * def rmepsilon(self, # <<<<<<<<<<<<<< + * queue_type=b"auto", + * bool connect=True, + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_48rmepsilon(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, PyObject *__pyx_v_queue_type, bool __pyx_v_connect, PyObject *__pyx_v_weight, __pyx_t_10basictypes_int64 __pyx_v_nstate, float __pyx_v_delta) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + struct __pyx_opt_args_9pywrapfst_11_MutableFst__rmepsilon __pyx_t_1; + __Pyx_RefNannySetupContext("rmepsilon", 0); + + /* "pywrapfst.pyx":2489 + * self. + * """ + * self._rmepsilon(queue_type, connect, weight, nstate, delta) # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_rmepsilon"); + __PYX_ERR(0, 2489, __pyx_L1_error) + } + __pyx_t_1.__pyx_n = 5; + __pyx_t_1.queue_type = __pyx_v_queue_type; + __pyx_t_1.connect = __pyx_v_connect; + __pyx_t_1.weight = __pyx_v_weight; + __pyx_t_1.nstate = __pyx_v_nstate; + __pyx_t_1.delta = __pyx_v_delta; + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_rmepsilon(__pyx_v_self, &__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2489, __pyx_L1_error) + + /* "pywrapfst.pyx":2490 + * """ + * self._rmepsilon(queue_type, connect, weight, nstate, delta) + * return self # <<<<<<<<<<<<<< + * + * cdef void _set_final(self, int64 state, weight=None) except *: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":2462 + * self._check_mutating_imethod() + * + * def rmepsilon(self, # <<<<<<<<<<<<<< + * queue_type=b"auto", + * bool connect=True, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.rmepsilon", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2492 + * return self + * + * cdef void _set_final(self, int64 state, weight=None) except *: # <<<<<<<<<<<<<< + * if not self._mfst.get().ValidStateId(state): + * raise FstIndexError("State index out of range") + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__set_final(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, struct __pyx_opt_args_9pywrapfst_11_MutableFst__set_final *__pyx_optional_args) { + PyObject *__pyx_v_weight = ((PyObject *)Py_None); + fst::script::WeightClass __pyx_v_wc; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + fst::script::WeightClass __pyx_t_4; + __Pyx_RefNannySetupContext("_set_final", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_weight = __pyx_optional_args->weight; + } + } + + /* "pywrapfst.pyx":2493 + * + * cdef void _set_final(self, int64 state, weight=None) except *: + * if not self._mfst.get().ValidStateId(state): # <<<<<<<<<<<<<< + * raise FstIndexError("State index out of range") + * cdef fst.WeightClass wc = _get_WeightClass_or_One(self.weight_type(), + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2493, __pyx_L1_error) + } + __pyx_t_1 = ((!(__pyx_v_self->_mfst.get()->ValidStateId(__pyx_v_state) != 0)) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":2494 + * cdef void _set_final(self, int64 state, weight=None) except *: + * if not self._mfst.get().ValidStateId(state): + * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< + * cdef fst.WeightClass wc = _get_WeightClass_or_One(self.weight_type(), + * weight) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__50, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 2494, __pyx_L1_error) + + /* "pywrapfst.pyx":2493 + * + * cdef void _set_final(self, int64 state, weight=None) except *: + * if not self._mfst.get().ValidStateId(state): # <<<<<<<<<<<<<< + * raise FstIndexError("State index out of range") + * cdef fst.WeightClass wc = _get_WeightClass_or_One(self.weight_type(), + */ + } + + /* "pywrapfst.pyx":2495 + * if not self._mfst.get().ValidStateId(state): + * raise FstIndexError("State index out of range") + * cdef fst.WeightClass wc = _get_WeightClass_or_One(self.weight_type(), # <<<<<<<<<<<<<< + * weight) + * if not self._mfst.get().SetFinal(state, wc): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "weight_type"); + __PYX_ERR(0, 2495, __pyx_L1_error) + } + + /* "pywrapfst.pyx":2496 + * raise FstIndexError("State index out of range") + * cdef fst.WeightClass wc = _get_WeightClass_or_One(self.weight_type(), + * weight) # <<<<<<<<<<<<<< + * if not self._mfst.get().SetFinal(state, wc): + * raise FstOpError("Incompatible or invalid weight") + */ + __pyx_t_4 = __pyx_f_9pywrapfst__get_WeightClass_or_One(((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.weight_type(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), 0), __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2495, __pyx_L1_error) + __pyx_v_wc = __pyx_t_4; + + /* "pywrapfst.pyx":2497 + * cdef fst.WeightClass wc = _get_WeightClass_or_One(self.weight_type(), + * weight) + * if not self._mfst.get().SetFinal(state, wc): # <<<<<<<<<<<<<< + * raise FstOpError("Incompatible or invalid weight") + * self._check_mutating_imethod() + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2497, __pyx_L1_error) + } + __pyx_t_1 = ((!(__pyx_v_self->_mfst.get()->SetFinal(__pyx_v_state, __pyx_v_wc) != 0)) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":2498 + * weight) + * if not self._mfst.get().SetFinal(state, wc): + * raise FstOpError("Incompatible or invalid weight") # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2498, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__51, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2498, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 2498, __pyx_L1_error) + + /* "pywrapfst.pyx":2497 + * cdef fst.WeightClass wc = _get_WeightClass_or_One(self.weight_type(), + * weight) + * if not self._mfst.get().SetFinal(state, wc): # <<<<<<<<<<<<<< + * raise FstOpError("Incompatible or invalid weight") + * self._check_mutating_imethod() + */ + } + + /* "pywrapfst.pyx":2499 + * if not self._mfst.get().SetFinal(state, wc): + * raise FstOpError("Incompatible or invalid weight") + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def set_final(self, int64 state, weight=None): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 2499, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2499, __pyx_L1_error) + + /* "pywrapfst.pyx":2492 + * return self + * + * cdef void _set_final(self, int64 state, weight=None) except *: # <<<<<<<<<<<<<< + * if not self._mfst.get().ValidStateId(state): + * raise FstIndexError("State index out of range") + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pywrapfst._MutableFst._set_final", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":2501 + * self._check_mutating_imethod() + * + * def set_final(self, int64 state, weight=None): # <<<<<<<<<<<<<< + * """ + * set_final(self, state, weight) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_51set_final(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_50set_final[] = "\n set_final(self, state, weight)\n\n Sets the final weight for a state.\n\n Args:\n state: The integer index of a state.\n weight: A Weight or weight string indicating the desired final weight; if\n omitted, it is set to semiring One.\n\n Returns:\n self.\n\n Raises:\n FstIndexError: State index out of range.\n FstOpError: Incompatible or invalid weight.\n\n See also: `set_start`.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_51set_final(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + __pyx_t_10basictypes_int64 __pyx_v_state; + PyObject *__pyx_v_weight = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_final (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_state,&__pyx_n_s_weight,0}; + PyObject* values[2] = {0,0}; + values[1] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weight); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_final") < 0)) __PYX_ERR(0, 2501, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_state = __Pyx_PyInt_As_int64_t(values[0]); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2501, __pyx_L3_error) + __pyx_v_weight = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("set_final", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2501, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.set_final", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_50set_final(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_state, __pyx_v_weight); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_50set_final(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, PyObject *__pyx_v_weight) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + struct __pyx_opt_args_9pywrapfst_11_MutableFst__set_final __pyx_t_1; + __Pyx_RefNannySetupContext("set_final", 0); + + /* "pywrapfst.pyx":2521 + * See also: `set_start`. + * """ + * self._set_final(state, weight) # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_set_final"); + __PYX_ERR(0, 2521, __pyx_L1_error) + } + __pyx_t_1.__pyx_n = 1; + __pyx_t_1.weight = __pyx_v_weight; + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_set_final(__pyx_v_self, __pyx_v_state, &__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2521, __pyx_L1_error) + + /* "pywrapfst.pyx":2522 + * """ + * self._set_final(state, weight) + * return self # <<<<<<<<<<<<<< + * + * cdef void _set_input_symbols(self, _SymbolTable syms) except *: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":2501 + * self._check_mutating_imethod() + * + * def set_final(self, int64 state, weight=None): # <<<<<<<<<<<<<< + * """ + * set_final(self, state, weight) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.set_final", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2524 + * return self + * + * cdef void _set_input_symbols(self, _SymbolTable syms) except *: # <<<<<<<<<<<<<< + * if syms is None: + * self._mfst.get().SetInputSymbols(NULL) + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__set_input_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + __Pyx_RefNannySetupContext("_set_input_symbols", 0); + + /* "pywrapfst.pyx":2525 + * + * cdef void _set_input_symbols(self, _SymbolTable syms) except *: + * if syms is None: # <<<<<<<<<<<<<< + * self._mfst.get().SetInputSymbols(NULL) + * return + */ + __pyx_t_1 = (((PyObject *)__pyx_v_syms) == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "pywrapfst.pyx":2526 + * cdef void _set_input_symbols(self, _SymbolTable syms) except *: + * if syms is None: + * self._mfst.get().SetInputSymbols(NULL) # <<<<<<<<<<<<<< + * return + * self._mfst.get().SetInputSymbols(syms._table) + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2526, __pyx_L1_error) + } + __pyx_v_self->_mfst.get()->SetInputSymbols(NULL); + + /* "pywrapfst.pyx":2527 + * if syms is None: + * self._mfst.get().SetInputSymbols(NULL) + * return # <<<<<<<<<<<<<< + * self._mfst.get().SetInputSymbols(syms._table) + * self._check_mutating_imethod() + */ + goto __pyx_L0; + + /* "pywrapfst.pyx":2525 + * + * cdef void _set_input_symbols(self, _SymbolTable syms) except *: + * if syms is None: # <<<<<<<<<<<<<< + * self._mfst.get().SetInputSymbols(NULL) + * return + */ + } + + /* "pywrapfst.pyx":2528 + * self._mfst.get().SetInputSymbols(NULL) + * return + * self._mfst.get().SetInputSymbols(syms._table) # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2528, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_syms) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 2528, __pyx_L1_error) + } + __pyx_v_self->_mfst.get()->SetInputSymbols(__pyx_v_syms->_table); + + /* "pywrapfst.pyx":2529 + * return + * self._mfst.get().SetInputSymbols(syms._table) + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def set_input_symbols(self, _SymbolTable syms): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 2529, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2529, __pyx_L1_error) + + /* "pywrapfst.pyx":2524 + * return self + * + * cdef void _set_input_symbols(self, _SymbolTable syms) except *: # <<<<<<<<<<<<<< + * if syms is None: + * self._mfst.get().SetInputSymbols(NULL) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst._set_input_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":2531 + * self._check_mutating_imethod() + * + * def set_input_symbols(self, _SymbolTable syms): # <<<<<<<<<<<<<< + * """ + * set_input_symbols(self, syms) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_53set_input_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_syms); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_52set_input_symbols[] = "\n set_input_symbols(self, syms)\n\n Sets the input symbol table.\n\n Passing None as a value will delete the input symbol table.\n\n Args:\n syms: A SymbolTable.\n\n Returns:\n self.\n\n See also: `set_output_symbols`.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_53set_input_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_syms) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_input_symbols (wrapper)", 0); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_syms), __pyx_ptype_9pywrapfst__SymbolTable, 1, "syms", 0))) __PYX_ERR(0, 2531, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_52set_input_symbols(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_syms)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_52set_input_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_input_symbols", 0); + + /* "pywrapfst.pyx":2547 + * See also: `set_output_symbols`. + * """ + * self._set_input_symbols(syms) # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_set_input_symbols"); + __PYX_ERR(0, 2547, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_set_input_symbols(__pyx_v_self, __pyx_v_syms); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2547, __pyx_L1_error) + + /* "pywrapfst.pyx":2548 + * """ + * self._set_input_symbols(syms) + * return self # <<<<<<<<<<<<<< + * + * cdef void _set_output_symbols(self, _SymbolTable syms) except *: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":2531 + * self._check_mutating_imethod() + * + * def set_input_symbols(self, _SymbolTable syms): # <<<<<<<<<<<<<< + * """ + * set_input_symbols(self, syms) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.set_input_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2550 + * return self + * + * cdef void _set_output_symbols(self, _SymbolTable syms) except *: # <<<<<<<<<<<<<< + * if syms is None: + * self._mfst.get().SetOutputSymbols(NULL) + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__set_output_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + __Pyx_RefNannySetupContext("_set_output_symbols", 0); + + /* "pywrapfst.pyx":2551 + * + * cdef void _set_output_symbols(self, _SymbolTable syms) except *: + * if syms is None: # <<<<<<<<<<<<<< + * self._mfst.get().SetOutputSymbols(NULL) + * return + */ + __pyx_t_1 = (((PyObject *)__pyx_v_syms) == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "pywrapfst.pyx":2552 + * cdef void _set_output_symbols(self, _SymbolTable syms) except *: + * if syms is None: + * self._mfst.get().SetOutputSymbols(NULL) # <<<<<<<<<<<<<< + * return + * self._mfst.get().SetOutputSymbols(syms._table) + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2552, __pyx_L1_error) + } + __pyx_v_self->_mfst.get()->SetOutputSymbols(NULL); + + /* "pywrapfst.pyx":2553 + * if syms is None: + * self._mfst.get().SetOutputSymbols(NULL) + * return # <<<<<<<<<<<<<< + * self._mfst.get().SetOutputSymbols(syms._table) + * self._check_mutating_imethod() + */ + goto __pyx_L0; + + /* "pywrapfst.pyx":2551 + * + * cdef void _set_output_symbols(self, _SymbolTable syms) except *: + * if syms is None: # <<<<<<<<<<<<<< + * self._mfst.get().SetOutputSymbols(NULL) + * return + */ + } + + /* "pywrapfst.pyx":2554 + * self._mfst.get().SetOutputSymbols(NULL) + * return + * self._mfst.get().SetOutputSymbols(syms._table) # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2554, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_syms) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 2554, __pyx_L1_error) + } + __pyx_v_self->_mfst.get()->SetOutputSymbols(__pyx_v_syms->_table); + + /* "pywrapfst.pyx":2555 + * return + * self._mfst.get().SetOutputSymbols(syms._table) + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def set_output_symbols(self, _SymbolTable syms): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 2555, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2555, __pyx_L1_error) + + /* "pywrapfst.pyx":2550 + * return self + * + * cdef void _set_output_symbols(self, _SymbolTable syms) except *: # <<<<<<<<<<<<<< + * if syms is None: + * self._mfst.get().SetOutputSymbols(NULL) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst._set_output_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":2557 + * self._check_mutating_imethod() + * + * def set_output_symbols(self, _SymbolTable syms): # <<<<<<<<<<<<<< + * """ + * set_output_symbols(self, syms) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_55set_output_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_syms); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_54set_output_symbols[] = "\n set_output_symbols(self, syms)\n\n Sets the output symbol table.\n\n Passing None as a value will delete the output symbol table.\n\n Args:\n syms: A SymbolTable.\n\n Returns:\n self.\n\n See also: `set_input_symbols`.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_55set_output_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_syms) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_output_symbols (wrapper)", 0); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_syms), __pyx_ptype_9pywrapfst__SymbolTable, 1, "syms", 0))) __PYX_ERR(0, 2557, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_54set_output_symbols(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_syms)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_54set_output_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_output_symbols", 0); + + /* "pywrapfst.pyx":2573 + * See also: `set_input_symbols`. + * """ + * self._set_output_symbols(syms) # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_set_output_symbols"); + __PYX_ERR(0, 2573, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_set_output_symbols(__pyx_v_self, __pyx_v_syms); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2573, __pyx_L1_error) + + /* "pywrapfst.pyx":2574 + * """ + * self._set_output_symbols(syms) + * return self # <<<<<<<<<<<<<< + * + * cdef void _set_properties(self, uint64 props, uint64 mask): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":2557 + * self._check_mutating_imethod() + * + * def set_output_symbols(self, _SymbolTable syms): # <<<<<<<<<<<<<< + * """ + * set_output_symbols(self, syms) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.set_output_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2576 + * return self + * + * cdef void _set_properties(self, uint64 props, uint64 mask): # <<<<<<<<<<<<<< + * self._mfst.get().SetProperties(props, mask) + * + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__set_properties(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_props, __pyx_t_10basictypes_uint64 __pyx_v_mask) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_set_properties", 0); + + /* "pywrapfst.pyx":2577 + * + * cdef void _set_properties(self, uint64 props, uint64 mask): + * self._mfst.get().SetProperties(props, mask) # <<<<<<<<<<<<<< + * + * def set_properties(self, uint64 props, uint64 mask): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2577, __pyx_L1_error) + } + __pyx_v_self->_mfst.get()->SetProperties(__pyx_v_props, __pyx_v_mask); + + /* "pywrapfst.pyx":2576 + * return self + * + * cdef void _set_properties(self, uint64 props, uint64 mask): # <<<<<<<<<<<<<< + * self._mfst.get().SetProperties(props, mask) + * + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_WriteUnraisable("pywrapfst._MutableFst._set_properties", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":2579 + * self._mfst.get().SetProperties(props, mask) + * + * def set_properties(self, uint64 props, uint64 mask): # <<<<<<<<<<<<<< + * """ + * set_properties(self, props, mask) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_57set_properties(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_56set_properties[] = "\n set_properties(self, props, mask)\n\n Sets the properties bits.\n\n Args:\n props: The properties to be set.\n mask: A mask to be applied to the `props` argument before setting the\n FST's properties.\n\n Returns:\n self.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_57set_properties(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + __pyx_t_10basictypes_uint64 __pyx_v_props; + __pyx_t_10basictypes_uint64 __pyx_v_mask; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_properties (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_props,&__pyx_n_s_mask,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_props)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mask)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("set_properties", 1, 2, 2, 1); __PYX_ERR(0, 2579, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_properties") < 0)) __PYX_ERR(0, 2579, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_props = __Pyx_PyInt_As_uint64_t(values[0]); if (unlikely((__pyx_v_props == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2579, __pyx_L3_error) + __pyx_v_mask = __Pyx_PyInt_As_uint64_t(values[1]); if (unlikely((__pyx_v_mask == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2579, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("set_properties", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2579, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.set_properties", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_56set_properties(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_props, __pyx_v_mask); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_56set_properties(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_props, __pyx_t_10basictypes_uint64 __pyx_v_mask) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_properties", 0); + + /* "pywrapfst.pyx":2593 + * self. + * """ + * self._set_properties(props, mask) # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_set_properties"); + __PYX_ERR(0, 2593, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_set_properties(__pyx_v_self, __pyx_v_props, __pyx_v_mask); + + /* "pywrapfst.pyx":2594 + * """ + * self._set_properties(props, mask) + * return self # <<<<<<<<<<<<<< + * + * cdef void _set_start(self, int64 state) except *: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":2579 + * self._mfst.get().SetProperties(props, mask) + * + * def set_properties(self, uint64 props, uint64 mask): # <<<<<<<<<<<<<< + * """ + * set_properties(self, props, mask) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.set_properties", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2596 + * return self + * + * cdef void _set_start(self, int64 state) except *: # <<<<<<<<<<<<<< + * if not self._mfst.get().SetStart(state): + * raise FstIndexError("State index out of range") + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__set_start(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("_set_start", 0); + + /* "pywrapfst.pyx":2597 + * + * cdef void _set_start(self, int64 state) except *: + * if not self._mfst.get().SetStart(state): # <<<<<<<<<<<<<< + * raise FstIndexError("State index out of range") + * self._check_mutating_imethod() + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2597, __pyx_L1_error) + } + __pyx_t_1 = ((!(__pyx_v_self->_mfst.get()->SetStart(__pyx_v_state) != 0)) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":2598 + * cdef void _set_start(self, int64 state) except *: + * if not self._mfst.get().SetStart(state): + * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 2598, __pyx_L1_error) + + /* "pywrapfst.pyx":2597 + * + * cdef void _set_start(self, int64 state) except *: + * if not self._mfst.get().SetStart(state): # <<<<<<<<<<<<<< + * raise FstIndexError("State index out of range") + * self._check_mutating_imethod() + */ + } + + /* "pywrapfst.pyx":2599 + * if not self._mfst.get().SetStart(state): + * raise FstIndexError("State index out of range") + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def set_start(self, int64 state): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 2599, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2599, __pyx_L1_error) + + /* "pywrapfst.pyx":2596 + * return self + * + * cdef void _set_start(self, int64 state) except *: # <<<<<<<<<<<<<< + * if not self._mfst.get().SetStart(state): + * raise FstIndexError("State index out of range") + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pywrapfst._MutableFst._set_start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":2601 + * self._check_mutating_imethod() + * + * def set_start(self, int64 state): # <<<<<<<<<<<<<< + * """ + * set_start(self, state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_59set_start(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_58set_start[] = "\n set_start(self, state)\n\n Sets a state to be the initial state state.\n\n Args:\n state: The integer index of a state.\n\n Returns:\n self.\n\n Raises:\n FstIndexError: State index out of range.\n\n See also: `set_final`.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_59set_start(PyObject *__pyx_v_self, PyObject *__pyx_arg_state) { + __pyx_t_10basictypes_int64 __pyx_v_state; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_start (wrapper)", 0); + assert(__pyx_arg_state); { + __pyx_v_state = __Pyx_PyInt_As_int64_t(__pyx_arg_state); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2601, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.set_start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_58set_start(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), ((__pyx_t_10basictypes_int64)__pyx_v_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_58set_start(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_start", 0); + + /* "pywrapfst.pyx":2618 + * See also: `set_final`. + * """ + * self._set_start(state) # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_set_start"); + __PYX_ERR(0, 2618, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_set_start(__pyx_v_self, __pyx_v_state); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2618, __pyx_L1_error) + + /* "pywrapfst.pyx":2619 + * """ + * self._set_start(state) + * return self # <<<<<<<<<<<<<< + * + * cdef void _topsort(self) except *: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":2601 + * self._check_mutating_imethod() + * + * def set_start(self, int64 state): # <<<<<<<<<<<<<< + * """ + * set_start(self, state) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.set_start", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2621 + * return self + * + * cdef void _topsort(self) except *: # <<<<<<<<<<<<<< + * # TopSort returns False if the FST is cyclic, and thus can't be TopSorted. + * if not fst.TopSort(self._mfst.get()): + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__topsort(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("_topsort", 0); + + /* "pywrapfst.pyx":2623 + * cdef void _topsort(self) except *: + * # TopSort returns False if the FST is cyclic, and thus can't be TopSorted. + * if not fst.TopSort(self._mfst.get()): # <<<<<<<<<<<<<< + * logging.warning("Cannot topsort cyclic FST.") + * self._check_mutating_imethod() + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2623, __pyx_L1_error) + } + __pyx_t_1 = ((!(fst::script::TopSort(__pyx_v_self->_mfst.get()) != 0)) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":2624 + * # TopSort returns False if the FST is cyclic, and thus can't be TopSorted. + * if not fst.TopSort(self._mfst.get()): + * logging.warning("Cannot topsort cyclic FST.") # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_logging); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2624, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_warning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2624, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__53, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2624, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "pywrapfst.pyx":2623 + * cdef void _topsort(self) except *: + * # TopSort returns False if the FST is cyclic, and thus can't be TopSorted. + * if not fst.TopSort(self._mfst.get()): # <<<<<<<<<<<<<< + * logging.warning("Cannot topsort cyclic FST.") + * self._check_mutating_imethod() + */ + } + + /* "pywrapfst.pyx":2625 + * if not fst.TopSort(self._mfst.get()): + * logging.warning("Cannot topsort cyclic FST.") + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def topsort(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 2625, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2625, __pyx_L1_error) + + /* "pywrapfst.pyx":2621 + * return self + * + * cdef void _topsort(self) except *: # <<<<<<<<<<<<<< + * # TopSort returns False if the FST is cyclic, and thus can't be TopSorted. + * if not fst.TopSort(self._mfst.get()): + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pywrapfst._MutableFst._topsort", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":2627 + * self._check_mutating_imethod() + * + * def topsort(self): # <<<<<<<<<<<<<< + * """ + * topsort(self) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_61topsort(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_60topsort[] = "\n topsort(self)\n\n Sorts transitions by state IDs.\n\n This operation destructively topologically sorts the FST, if it is acyclic;\n otherwise it remains unchanged. Once sorted, all transitions are from lower\n state IDs to higher state IDs\n\n Returns:\n self.\n\n See also: `arcsort`.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_61topsort(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("topsort (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_60topsort(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_60topsort(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("topsort", 0); + + /* "pywrapfst.pyx":2642 + * See also: `arcsort`. + * """ + * self._topsort() # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_topsort"); + __PYX_ERR(0, 2642, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_topsort(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2642, __pyx_L1_error) + + /* "pywrapfst.pyx":2643 + * """ + * self._topsort() + * return self # <<<<<<<<<<<<<< + * + * cdef void _union(self, _Fst ifst) except *: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":2627 + * self._check_mutating_imethod() + * + * def topsort(self): # <<<<<<<<<<<<<< + * """ + * topsort(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.topsort", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2645 + * return self + * + * cdef void _union(self, _Fst ifst) except *: # <<<<<<<<<<<<<< + * fst.Union(self._mfst.get(), deref(ifst._fst)) + * self._check_mutating_imethod() + */ + +static void __pyx_f_9pywrapfst_11_MutableFst__union(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_union", 0); + + /* "pywrapfst.pyx":2646 + * + * cdef void _union(self, _Fst ifst) except *: + * fst.Union(self._mfst.get(), deref(ifst._fst)) # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2646, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 2646, __pyx_L1_error) + } + fst::script::Union(__pyx_v_self->_mfst.get(), (*__pyx_v_ifst->_fst)); + + /* "pywrapfst.pyx":2647 + * cdef void _union(self, _Fst ifst) except *: + * fst.Union(self._mfst.get(), deref(ifst._fst)) + * self._check_mutating_imethod() # <<<<<<<<<<<<<< + * + * def union(self, _Fst ifst): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); + __PYX_ERR(0, 2647, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_check_mutating_imethod(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2647, __pyx_L1_error) + + /* "pywrapfst.pyx":2645 + * return self + * + * cdef void _union(self, _Fst ifst) except *: # <<<<<<<<<<<<<< + * fst.Union(self._mfst.get(), deref(ifst._fst)) + * self._check_mutating_imethod() + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst._union", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":2649 + * self._check_mutating_imethod() + * + * def union(self, _Fst ifst): # <<<<<<<<<<<<<< + * """ + * union(self, ifst) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_63union(PyObject *__pyx_v_self, PyObject *__pyx_v_ifst); /*proto*/ +static char __pyx_doc_9pywrapfst_11_MutableFst_62union[] = "\n union(self, ifst)\n\n Computes the union (sum) of two FSTs.\n\n This operation computes the union (sum) of two FSTs. If A transduces string\n x to y with weight a and B transduces string w to v with weight b, then\n their union transduces x to y with weight a and w to v with weight b.\n\n Args:\n ifst: The second input FST.\n\n Returns:\n self.\n "; +static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_63union(PyObject *__pyx_v_self, PyObject *__pyx_v_ifst) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("union (wrapper)", 0); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst), __pyx_ptype_9pywrapfst__Fst, 1, "ifst", 0))) __PYX_ERR(0, 2649, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_62union(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_ifst)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_62union(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("union", 0); + + /* "pywrapfst.pyx":2665 + * self. + * """ + * self._union(ifst) # <<<<<<<<<<<<<< + * return self + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_union"); + __PYX_ERR(0, 2665, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_union(__pyx_v_self, __pyx_v_ifst); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2665, __pyx_L1_error) + + /* "pywrapfst.pyx":2666 + * """ + * self._union(ifst) + * return self # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":2649 + * self._check_mutating_imethod() + * + * def union(self, _Fst ifst): # <<<<<<<<<<<<<< + * """ + * union(self, ifst) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._MutableFst.union", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2691 + * + * + * cdef _Fst _init_Fst(FstClass_ptr tfst): # <<<<<<<<<<<<<< + * if tfst.Properties(fst.kError, True): + * raise FstOpError("Operation failed") + */ + +static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst__init_Fst(__pyx_t_9pywrapfst_FstClass_ptr __pyx_v_tfst) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ofst = 0; + struct __pyx_obj_9pywrapfst__Fst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("_init_Fst", 0); + + /* "pywrapfst.pyx":2692 + * + * cdef _Fst _init_Fst(FstClass_ptr tfst): + * if tfst.Properties(fst.kError, True): # <<<<<<<<<<<<<< + * raise FstOpError("Operation failed") + * cdef _Fst ofst = _Fst.__new__(_Fst) + */ + __pyx_t_1 = (__pyx_v_tfst->Properties(fst::kError, 1) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":2693 + * cdef _Fst _init_Fst(FstClass_ptr tfst): + * if tfst.Properties(fst.kError, True): + * raise FstOpError("Operation failed") # <<<<<<<<<<<<<< + * cdef _Fst ofst = _Fst.__new__(_Fst) + * ofst._fst.reset(tfst) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2693, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2693, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 2693, __pyx_L1_error) + + /* "pywrapfst.pyx":2692 + * + * cdef _Fst _init_Fst(FstClass_ptr tfst): + * if tfst.Properties(fst.kError, True): # <<<<<<<<<<<<<< + * raise FstOpError("Operation failed") + * cdef _Fst ofst = _Fst.__new__(_Fst) + */ + } + + /* "pywrapfst.pyx":2694 + * if tfst.Properties(fst.kError, True): + * raise FstOpError("Operation failed") + * cdef _Fst ofst = _Fst.__new__(_Fst) # <<<<<<<<<<<<<< + * ofst._fst.reset(tfst) + * return ofst + */ + __pyx_t_3 = __pyx_tp_new_9pywrapfst__Fst(((PyTypeObject *)__pyx_ptype_9pywrapfst__Fst), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2694, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_9pywrapfst__Fst)))) __PYX_ERR(0, 2694, __pyx_L1_error) + __pyx_v_ofst = ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "pywrapfst.pyx":2695 + * raise FstOpError("Operation failed") + * cdef _Fst ofst = _Fst.__new__(_Fst) + * ofst._fst.reset(tfst) # <<<<<<<<<<<<<< + * return ofst + * + */ + if (unlikely(((PyObject *)__pyx_v_ofst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 2695, __pyx_L1_error) + } + __pyx_v_ofst->_fst.reset(__pyx_v_tfst); + + /* "pywrapfst.pyx":2696 + * cdef _Fst ofst = _Fst.__new__(_Fst) + * ofst._fst.reset(tfst) + * return ofst # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_ofst)); + __pyx_r = __pyx_v_ofst; + goto __pyx_L0; + + /* "pywrapfst.pyx":2691 + * + * + * cdef _Fst _init_Fst(FstClass_ptr tfst): # <<<<<<<<<<<<<< + * if tfst.Properties(fst.kError, True): + * raise FstOpError("Operation failed") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pywrapfst._init_Fst", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_ofst); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2699 + * + * + * cdef _MutableFst _init_MutableFst(MutableFstClass_ptr tfst): # <<<<<<<<<<<<<< + * if tfst.Properties(fst.kError, True): + * raise FstOpError("Operation failed") + */ + +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst__init_MutableFst(__pyx_t_9pywrapfst_MutableFstClass_ptr __pyx_v_tfst) { + struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_ofst = 0; + struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("_init_MutableFst", 0); + + /* "pywrapfst.pyx":2700 + * + * cdef _MutableFst _init_MutableFst(MutableFstClass_ptr tfst): + * if tfst.Properties(fst.kError, True): # <<<<<<<<<<<<<< + * raise FstOpError("Operation failed") + * cdef _MutableFst ofst = _MutableFst.__new__(_MutableFst) + */ + __pyx_t_1 = (__pyx_v_tfst->Properties(fst::kError, 1) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":2701 + * cdef _MutableFst _init_MutableFst(MutableFstClass_ptr tfst): + * if tfst.Properties(fst.kError, True): + * raise FstOpError("Operation failed") # <<<<<<<<<<<<<< + * cdef _MutableFst ofst = _MutableFst.__new__(_MutableFst) + * ofst._fst.reset(tfst) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2701, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__55, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2701, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 2701, __pyx_L1_error) + + /* "pywrapfst.pyx":2700 + * + * cdef _MutableFst _init_MutableFst(MutableFstClass_ptr tfst): + * if tfst.Properties(fst.kError, True): # <<<<<<<<<<<<<< + * raise FstOpError("Operation failed") + * cdef _MutableFst ofst = _MutableFst.__new__(_MutableFst) + */ + } + + /* "pywrapfst.pyx":2702 + * if tfst.Properties(fst.kError, True): + * raise FstOpError("Operation failed") + * cdef _MutableFst ofst = _MutableFst.__new__(_MutableFst) # <<<<<<<<<<<<<< + * ofst._fst.reset(tfst) + * # Makes a copy of it as the derived type! Cool. + */ + __pyx_t_3 = __pyx_tp_new_9pywrapfst__MutableFst(((PyTypeObject *)__pyx_ptype_9pywrapfst__MutableFst), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2702, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_9pywrapfst__MutableFst)))) __PYX_ERR(0, 2702, __pyx_L1_error) + __pyx_v_ofst = ((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "pywrapfst.pyx":2703 + * raise FstOpError("Operation failed") + * cdef _MutableFst ofst = _MutableFst.__new__(_MutableFst) + * ofst._fst.reset(tfst) # <<<<<<<<<<<<<< + * # Makes a copy of it as the derived type! Cool. + * ofst._mfst = static_pointer_cast[fst.MutableFstClass, fst.FstClass](ofst._fst) + */ + if (unlikely(((PyObject *)__pyx_v_ofst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 2703, __pyx_L1_error) + } + __pyx_v_ofst->__pyx_base._fst.reset(__pyx_v_tfst); + + /* "pywrapfst.pyx":2705 + * ofst._fst.reset(tfst) + * # Makes a copy of it as the derived type! Cool. + * ofst._mfst = static_pointer_cast[fst.MutableFstClass, fst.FstClass](ofst._fst) # <<<<<<<<<<<<<< + * return ofst + * + */ + if (unlikely(((PyObject *)__pyx_v_ofst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 2705, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_ofst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 2705, __pyx_L1_error) + } + __pyx_v_ofst->_mfst = std::static_pointer_cast(__pyx_v_ofst->__pyx_base._fst); + + /* "pywrapfst.pyx":2706 + * # Makes a copy of it as the derived type! Cool. + * ofst._mfst = static_pointer_cast[fst.MutableFstClass, fst.FstClass](ofst._fst) + * return ofst # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_ofst)); + __pyx_r = __pyx_v_ofst; + goto __pyx_L0; + + /* "pywrapfst.pyx":2699 + * + * + * cdef _MutableFst _init_MutableFst(MutableFstClass_ptr tfst): # <<<<<<<<<<<<<< + * if tfst.Properties(fst.kError, True): + * raise FstOpError("Operation failed") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pywrapfst._init_MutableFst", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_ofst); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2709 + * + * + * cdef _Fst _init_XFst(FstClass_ptr tfst): # <<<<<<<<<<<<<< + * if tfst.Properties(fst.kMutable, True): + * return _init_MutableFst(static_cast[MutableFstClass_ptr](tfst)) + */ + +static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst__init_XFst(__pyx_t_9pywrapfst_FstClass_ptr __pyx_v_tfst) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("_init_XFst", 0); + + /* "pywrapfst.pyx":2710 + * + * cdef _Fst _init_XFst(FstClass_ptr tfst): + * if tfst.Properties(fst.kMutable, True): # <<<<<<<<<<<<<< + * return _init_MutableFst(static_cast[MutableFstClass_ptr](tfst)) + * else: + */ + __pyx_t_1 = (__pyx_v_tfst->Properties(fst::kMutable, 1) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":2711 + * cdef _Fst _init_XFst(FstClass_ptr tfst): + * if tfst.Properties(fst.kMutable, True): + * return _init_MutableFst(static_cast[MutableFstClass_ptr](tfst)) # <<<<<<<<<<<<<< + * else: + * return _init_Fst(tfst) + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_2 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(static_cast<__pyx_t_9pywrapfst_MutableFstClass_ptr>(__pyx_v_tfst))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2711, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_2); + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":2710 + * + * cdef _Fst _init_XFst(FstClass_ptr tfst): + * if tfst.Properties(fst.kMutable, True): # <<<<<<<<<<<<<< + * return _init_MutableFst(static_cast[MutableFstClass_ptr](tfst)) + * else: + */ + } + + /* "pywrapfst.pyx":2713 + * return _init_MutableFst(static_cast[MutableFstClass_ptr](tfst)) + * else: + * return _init_Fst(tfst) # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_2 = ((PyObject *)__pyx_f_9pywrapfst__init_Fst(__pyx_v_tfst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2713, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_2); + __pyx_t_2 = 0; + goto __pyx_L0; + } + + /* "pywrapfst.pyx":2709 + * + * + * cdef _Fst _init_XFst(FstClass_ptr tfst): # <<<<<<<<<<<<<< + * if tfst.Properties(fst.kMutable, True): + * return _init_MutableFst(static_cast[MutableFstClass_ptr](tfst)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pywrapfst._init_XFst", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2716 + * + * + * cdef _MutableFst _create_Fst(arc_type=b"standard"): # <<<<<<<<<<<<<< + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(tostring(arc_type))) + */ + +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst__create_Fst(struct __pyx_opt_args_9pywrapfst__create_Fst *__pyx_optional_args) { + PyObject *__pyx_v_arc_type = ((PyObject *)__pyx_n_b_standard); + std::unique_ptr __pyx_v_tfst; + struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + std::string __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("_create_Fst", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_arc_type = __pyx_optional_args->arc_type; + } + } + + /* "pywrapfst.pyx":2718 + * cdef _MutableFst _create_Fst(arc_type=b"standard"): + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(tostring(arc_type))) # <<<<<<<<<<<<<< + * if tfst.get() == NULL: + * raise FstOpError("Unknown arc type: {!r}".format(arc_type)) + */ + __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_arc_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2718, __pyx_L1_error) + __pyx_v_tfst.reset(new fst::script::VectorFstClass(__pyx_t_1)); + + /* "pywrapfst.pyx":2719 + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(tostring(arc_type))) + * if tfst.get() == NULL: # <<<<<<<<<<<<<< + * raise FstOpError("Unknown arc type: {!r}".format(arc_type)) + * return _init_MutableFst(tfst.release()) + */ + __pyx_t_2 = ((__pyx_v_tfst.get() == NULL) != 0); + if (__pyx_t_2) { + + /* "pywrapfst.pyx":2720 + * tfst.reset(new fst.VectorFstClass(tostring(arc_type))) + * if tfst.get() == NULL: + * raise FstOpError("Unknown arc type: {!r}".format(arc_type)) # <<<<<<<<<<<<<< + * return _init_MutableFst(tfst.release()) + * + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2720, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Unknown_arc_type_r, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2720, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + if (!__pyx_t_7) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_arc_type); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2720, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_arc_type}; + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2720, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_arc_type}; + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2720, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2720, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_INCREF(__pyx_v_arc_type); + __Pyx_GIVEREF(__pyx_v_arc_type); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_arc_type); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2720, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_6) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2720, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2720, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2720, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2720, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2720, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 2720, __pyx_L1_error) + + /* "pywrapfst.pyx":2719 + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(tostring(arc_type))) + * if tfst.get() == NULL: # <<<<<<<<<<<<<< + * raise FstOpError("Unknown arc type: {!r}".format(arc_type)) + * return _init_MutableFst(tfst.release()) + */ + } + + /* "pywrapfst.pyx":2721 + * if tfst.get() == NULL: + * raise FstOpError("Unknown arc type: {!r}".format(arc_type)) + * return _init_MutableFst(tfst.release()) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst.release())); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2721, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = ((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":2716 + * + * + * cdef _MutableFst _create_Fst(arc_type=b"standard"): # <<<<<<<<<<<<<< + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(tostring(arc_type))) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pywrapfst._create_Fst", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2724 + * + * + * cpdef _Fst _read(filename): # <<<<<<<<<<<<<< + * cdef unique_ptr[fst.FstClass] tfst + * tfst.reset(fst.FstClass.Read(tostring(filename))) + */ + +static PyObject *__pyx_pw_9pywrapfst_13_read(PyObject *__pyx_self, PyObject *__pyx_v_filename); /*proto*/ +static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst__read(PyObject *__pyx_v_filename, CYTHON_UNUSED int __pyx_skip_dispatch) { + std::unique_ptr __pyx_v_tfst; + struct __pyx_obj_9pywrapfst__Fst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + std::string __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("_read", 0); + + /* "pywrapfst.pyx":2726 + * cpdef _Fst _read(filename): + * cdef unique_ptr[fst.FstClass] tfst + * tfst.reset(fst.FstClass.Read(tostring(filename))) # <<<<<<<<<<<<<< + * if tfst.get() == NULL: + * raise FstIOError("Read failed: {!r}".format(filename)) + */ + __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_filename, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2726, __pyx_L1_error) + __pyx_v_tfst.reset(fst::script::FstClass::Read(__pyx_t_1)); + + /* "pywrapfst.pyx":2727 + * cdef unique_ptr[fst.FstClass] tfst + * tfst.reset(fst.FstClass.Read(tostring(filename))) + * if tfst.get() == NULL: # <<<<<<<<<<<<<< + * raise FstIOError("Read failed: {!r}".format(filename)) + * return _init_XFst(tfst.release()) + */ + __pyx_t_2 = ((__pyx_v_tfst.get() == NULL) != 0); + if (__pyx_t_2) { + + /* "pywrapfst.pyx":2728 + * tfst.reset(fst.FstClass.Read(tostring(filename))) + * if tfst.get() == NULL: + * raise FstIOError("Read failed: {!r}".format(filename)) # <<<<<<<<<<<<<< + * return _init_XFst(tfst.release()) + * + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIOError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2728, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Read_failed_r, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2728, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + if (!__pyx_t_7) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_filename); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2728, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_filename}; + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2728, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_filename}; + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2728, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2728, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_INCREF(__pyx_v_filename); + __Pyx_GIVEREF(__pyx_v_filename); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_filename); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2728, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_6) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2728, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2728, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2728, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2728, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2728, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 2728, __pyx_L1_error) + + /* "pywrapfst.pyx":2727 + * cdef unique_ptr[fst.FstClass] tfst + * tfst.reset(fst.FstClass.Read(tostring(filename))) + * if tfst.get() == NULL: # <<<<<<<<<<<<<< + * raise FstIOError("Read failed: {!r}".format(filename)) + * return _init_XFst(tfst.release()) + */ + } + + /* "pywrapfst.pyx":2729 + * if tfst.get() == NULL: + * raise FstIOError("Read failed: {!r}".format(filename)) + * return _init_XFst(tfst.release()) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_XFst(__pyx_v_tfst.release())); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2729, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":2724 + * + * + * cpdef _Fst _read(filename): # <<<<<<<<<<<<<< + * cdef unique_ptr[fst.FstClass] tfst + * tfst.reset(fst.FstClass.Read(tostring(filename))) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pywrapfst._read", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_13_read(PyObject *__pyx_self, PyObject *__pyx_v_filename); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_13_read(PyObject *__pyx_self, PyObject *__pyx_v_filename) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_read (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_12_read(__pyx_self, ((PyObject *)__pyx_v_filename)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_12_read(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_filename) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_read", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__read(__pyx_v_filename, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2724, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._read", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2732 + * + * + * cpdef _Fst _read_from_string(state): # <<<<<<<<<<<<<< + * cdef stringstream sstrm + * sstrm << tostring(state) + */ + +static PyObject *__pyx_pw_9pywrapfst_15_read_from_string(PyObject *__pyx_self, PyObject *__pyx_v_state); /*proto*/ +static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst__read_from_string(PyObject *__pyx_v_state, CYTHON_UNUSED int __pyx_skip_dispatch) { + std::stringstream __pyx_v_sstrm; + std::unique_ptr __pyx_v_tfst; + struct __pyx_obj_9pywrapfst__Fst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + std::string __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("_read_from_string", 0); + + /* "pywrapfst.pyx":2734 + * cpdef _Fst _read_from_string(state): + * cdef stringstream sstrm + * sstrm << tostring(state) # <<<<<<<<<<<<<< + * cdef unique_ptr[fst.FstClass] tfst + * tfst.reset(fst.FstClass.ReadFromStream(sstrm, b"")) + */ + __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_state, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2734, __pyx_L1_error) + (__pyx_v_sstrm << __pyx_t_1); + + /* "pywrapfst.pyx":2736 + * sstrm << tostring(state) + * cdef unique_ptr[fst.FstClass] tfst + * tfst.reset(fst.FstClass.ReadFromStream(sstrm, b"")) # <<<<<<<<<<<<<< + * if tfst.get() == NULL: + * raise FstIOError("Read failed: ") + */ + __pyx_t_1 = __pyx_convert_string_from_py_std__in_string(__pyx_kp_b_pywrapfst); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2736, __pyx_L1_error) + __pyx_v_tfst.reset(fst::script::FstClass::Read(__pyx_v_sstrm, __pyx_t_1)); + + /* "pywrapfst.pyx":2737 + * cdef unique_ptr[fst.FstClass] tfst + * tfst.reset(fst.FstClass.ReadFromStream(sstrm, b"")) + * if tfst.get() == NULL: # <<<<<<<<<<<<<< + * raise FstIOError("Read failed: ") + * return _init_XFst(tfst.release()) + */ + __pyx_t_2 = ((__pyx_v_tfst.get() == NULL) != 0); + if (__pyx_t_2) { + + /* "pywrapfst.pyx":2738 + * tfst.reset(fst.FstClass.ReadFromStream(sstrm, b"")) + * if tfst.get() == NULL: + * raise FstIOError("Read failed: ") # <<<<<<<<<<<<<< + * return _init_XFst(tfst.release()) + * + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIOError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2738, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__56, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2738, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 2738, __pyx_L1_error) + + /* "pywrapfst.pyx":2737 + * cdef unique_ptr[fst.FstClass] tfst + * tfst.reset(fst.FstClass.ReadFromStream(sstrm, b"")) + * if tfst.get() == NULL: # <<<<<<<<<<<<<< + * raise FstIOError("Read failed: ") + * return _init_XFst(tfst.release()) + */ + } + + /* "pywrapfst.pyx":2739 + * if tfst.get() == NULL: + * raise FstIOError("Read failed: ") + * return _init_XFst(tfst.release()) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_4 = ((PyObject *)__pyx_f_9pywrapfst__init_XFst(__pyx_v_tfst.release())); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2739, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_4); + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":2732 + * + * + * cpdef _Fst _read_from_string(state): # <<<<<<<<<<<<<< + * cdef stringstream sstrm + * sstrm << tostring(state) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pywrapfst._read_from_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_15_read_from_string(PyObject *__pyx_self, PyObject *__pyx_v_state); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_15_read_from_string(PyObject *__pyx_self, PyObject *__pyx_v_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_read_from_string (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_14_read_from_string(__pyx_self, ((PyObject *)__pyx_v_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_14_read_from_string(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("_read_from_string", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__read_from_string(__pyx_v_state, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2732, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._read_from_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2759 + * """ + * + * def __new__(cls, arc_type=b"standard"): # <<<<<<<<<<<<<< + * return _create_Fst(arc_type) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_3Fst_1__new__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_9pywrapfst_3Fst_1__new__ = {"__new__", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_1__new__, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_9pywrapfst_3Fst_1__new__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED PyObject *__pyx_v_cls = 0; + PyObject *__pyx_v_arc_type = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__new__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cls,&__pyx_n_s_arc_type,0}; + PyObject* values[2] = {0,0}; + values[1] = ((PyObject *)((PyObject*)__pyx_n_b_standard)); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_cls)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_arc_type); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__new__") < 0)) __PYX_ERR(0, 2759, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_cls = values[0]; + __pyx_v_arc_type = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__new__", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2759, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.Fst.__new__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_3Fst___new__(__pyx_self, __pyx_v_cls, __pyx_v_arc_type); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_3Fst___new__(CYTHON_UNUSED PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_cls, PyObject *__pyx_v_arc_type) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + struct __pyx_opt_args_9pywrapfst__create_Fst __pyx_t_2; + __Pyx_RefNannySetupContext("__new__", 0); + + /* "pywrapfst.pyx":2760 + * + * def __new__(cls, arc_type=b"standard"): + * return _create_Fst(arc_type) # <<<<<<<<<<<<<< + * + * @staticmethod + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 1; + __pyx_t_2.arc_type = __pyx_v_arc_type; + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__create_Fst(&__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2760, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":2759 + * """ + * + * def __new__(cls, arc_type=b"standard"): # <<<<<<<<<<<<<< + * return _create_Fst(arc_type) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Fst.__new__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2763 + * + * @staticmethod + * def read(filename): # <<<<<<<<<<<<<< + * """ + * read(filename): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_3Fst_3read(PyObject *__pyx_self, PyObject *__pyx_v_filename); /*proto*/ +static char __pyx_doc_9pywrapfst_3Fst_2read[] = "\n read(filename):\n\n Reads an FST from a file.\n\n Args:\n filename: The string location of the input file.\n\n Returns:\n An FST object.\n\n Raises:\n FstIOError: Read failed.\n "; +static PyMethodDef __pyx_mdef_9pywrapfst_3Fst_3read = {"read", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_3read, METH_O, __pyx_doc_9pywrapfst_3Fst_2read}; +static PyObject *__pyx_pw_9pywrapfst_3Fst_3read(PyObject *__pyx_self, PyObject *__pyx_v_filename) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("read (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_3Fst_2read(__pyx_self, ((PyObject *)__pyx_v_filename)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_3Fst_2read(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_filename) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("read", 0); + + /* "pywrapfst.pyx":2778 + * FstIOError: Read failed. + * """ + * return _read(filename) # <<<<<<<<<<<<<< + * + * @staticmethod + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__read(__pyx_v_filename, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2778, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":2763 + * + * @staticmethod + * def read(filename): # <<<<<<<<<<<<<< + * """ + * read(filename): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Fst.read", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2781 + * + * @staticmethod + * def read_from_string(state): # <<<<<<<<<<<<<< + * """ + * read_from_string(string, fst_type=None) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_3Fst_5read_from_string(PyObject *__pyx_self, PyObject *__pyx_v_state); /*proto*/ +static char __pyx_doc_9pywrapfst_3Fst_4read_from_string[] = "\n read_from_string(string, fst_type=None)\n\n Reads an FST from a serialized string.\n\n Args:\n state: A string containing the serialized FST.\n\n Returns:\n An FST object.\n\n Raises:\n FstIOError: Read failed.\n FstOpError: Read-time conversion failed.\n\n See also: `write_to_string`.\n "; +static PyMethodDef __pyx_mdef_9pywrapfst_3Fst_5read_from_string = {"read_from_string", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_5read_from_string, METH_O, __pyx_doc_9pywrapfst_3Fst_4read_from_string}; +static PyObject *__pyx_pw_9pywrapfst_3Fst_5read_from_string(PyObject *__pyx_self, PyObject *__pyx_v_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("read_from_string (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_3Fst_4read_from_string(__pyx_self, ((PyObject *)__pyx_v_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_3Fst_4read_from_string(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("read_from_string", 0); + + /* "pywrapfst.pyx":2799 + * See also: `write_to_string`. + * """ + * return _read_from_string(state) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__read_from_string(__pyx_v_state, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2799, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":2781 + * + * @staticmethod + * def read_from_string(state): # <<<<<<<<<<<<<< + * """ + * read_from_string(string, fst_type=None) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Fst.read_from_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2914 + * """ + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "".format(id(self)) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_3Arc_1__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_3Arc_1__repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_3Arc___repr__(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_3Arc___repr__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "pywrapfst.pyx":2915 + * + * def __repr__(self): + * return "".format(id(self)) # <<<<<<<<<<<<<< + * + * def __init__(self, int64 ilabel, int64 olabel, weight, int64 nextstate): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Arc_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2915, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2915, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self)); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2915, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2915, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2915, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2915, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2915, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2915, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":2914 + * """ + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "".format(id(self)) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pywrapfst.Arc.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2917 + * return "".format(id(self)) + * + * def __init__(self, int64 ilabel, int64 olabel, weight, int64 nextstate): # <<<<<<<<<<<<<< + * cdef fst.WeightClass wc = _get_WeightClass_or_One(b"tropical", weight) + * self._arc.reset(new fst.ArcClass(ilabel, olabel, wc, nextstate)) + */ + +/* Python wrapper */ +static int __pyx_pw_9pywrapfst_3Arc_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_9pywrapfst_3Arc_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + __pyx_t_10basictypes_int64 __pyx_v_ilabel; + __pyx_t_10basictypes_int64 __pyx_v_olabel; + PyObject *__pyx_v_weight = 0; + __pyx_t_10basictypes_int64 __pyx_v_nextstate; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ilabel,&__pyx_n_s_olabel,&__pyx_n_s_weight,&__pyx_n_s_nextstate,0}; + PyObject* values[4] = {0,0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ilabel)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_olabel)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 1); __PYX_ERR(0, 2917, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weight)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 2); __PYX_ERR(0, 2917, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nextstate)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 3); __PYX_ERR(0, 2917, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 2917, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + } + __pyx_v_ilabel = __Pyx_PyInt_As_int64_t(values[0]); if (unlikely((__pyx_v_ilabel == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2917, __pyx_L3_error) + __pyx_v_olabel = __Pyx_PyInt_As_int64_t(values[1]); if (unlikely((__pyx_v_olabel == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2917, __pyx_L3_error) + __pyx_v_weight = values[2]; + __pyx_v_nextstate = __Pyx_PyInt_As_int64_t(values[3]); if (unlikely((__pyx_v_nextstate == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2917, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2917, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.Arc.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_3Arc_2__init__(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self), __pyx_v_ilabel, __pyx_v_olabel, __pyx_v_weight, __pyx_v_nextstate); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pywrapfst_3Arc_2__init__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_ilabel, __pyx_t_10basictypes_int64 __pyx_v_olabel, PyObject *__pyx_v_weight, __pyx_t_10basictypes_int64 __pyx_v_nextstate) { + fst::script::WeightClass __pyx_v_wc; + int __pyx_r; + __Pyx_RefNannyDeclarations + std::string __pyx_t_1; + fst::script::WeightClass __pyx_t_2; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "pywrapfst.pyx":2918 + * + * def __init__(self, int64 ilabel, int64 olabel, weight, int64 nextstate): + * cdef fst.WeightClass wc = _get_WeightClass_or_One(b"tropical", weight) # <<<<<<<<<<<<<< + * self._arc.reset(new fst.ArcClass(ilabel, olabel, wc, nextstate)) + * + */ + __pyx_t_1 = __pyx_convert_string_from_py_std__in_string(__pyx_n_b_tropical); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2918, __pyx_L1_error) + __pyx_t_2 = __pyx_f_9pywrapfst__get_WeightClass_or_One(__pyx_t_1, __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2918, __pyx_L1_error) + __pyx_v_wc = __pyx_t_2; + + /* "pywrapfst.pyx":2919 + * def __init__(self, int64 ilabel, int64 olabel, weight, int64 nextstate): + * cdef fst.WeightClass wc = _get_WeightClass_or_One(b"tropical", weight) + * self._arc.reset(new fst.ArcClass(ilabel, olabel, wc, nextstate)) # <<<<<<<<<<<<<< + * + * cpdef Arc copy(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_arc"); + __PYX_ERR(0, 2919, __pyx_L1_error) + } + __pyx_v_self->_arc.reset(new fst::script::ArcClass(__pyx_v_ilabel, __pyx_v_olabel, __pyx_v_wc, __pyx_v_nextstate)); + + /* "pywrapfst.pyx":2917 + * return "".format(id(self)) + * + * def __init__(self, int64 ilabel, int64 olabel, weight, int64 nextstate): # <<<<<<<<<<<<<< + * cdef fst.WeightClass wc = _get_WeightClass_or_One(b"tropical", weight) + * self._arc.reset(new fst.ArcClass(ilabel, olabel, wc, nextstate)) + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst.Arc.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2921 + * self._arc.reset(new fst.ArcClass(ilabel, olabel, wc, nextstate)) + * + * cpdef Arc copy(self): # <<<<<<<<<<<<<< + * return Arc(self.ilabel, self.olabel, self.weight, self.nextstate) + * + */ + +static PyObject *__pyx_pw_9pywrapfst_3Arc_5copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static struct __pyx_obj_9pywrapfst_Arc *__pyx_f_9pywrapfst_3Arc_copy(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, int __pyx_skip_dispatch) { + struct __pyx_obj_9pywrapfst_Arc *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("copy", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_copy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2921, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_3Arc_5copy)) { + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2921, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2921, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pywrapfst_Arc))))) __PYX_ERR(0, 2921, __pyx_L1_error) + __pyx_r = ((struct __pyx_obj_9pywrapfst_Arc *)__pyx_t_2); + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":2922 + * + * cpdef Arc copy(self): + * return Arc(self.ilabel, self.olabel, self.weight, self.nextstate) # <<<<<<<<<<<<<< + * + * property ilabel: + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_ilabel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2922, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_olabel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2922, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_weight); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2922, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_nextstate); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2922, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2922, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pywrapfst_Arc), __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2922, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_r = ((struct __pyx_obj_9pywrapfst_Arc *)__pyx_t_4); + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":2921 + * self._arc.reset(new fst.ArcClass(ilabel, olabel, wc, nextstate)) + * + * cpdef Arc copy(self): # <<<<<<<<<<<<<< + * return Arc(self.ilabel, self.olabel, self.weight, self.nextstate) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pywrapfst.Arc.copy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_3Arc_5copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_3Arc_5copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("copy (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_3Arc_4copy(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_3Arc_4copy(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("copy", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_3Arc_copy(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2921, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Arc.copy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2926 + * property ilabel: + * + * def __get__(self): # <<<<<<<<<<<<<< + * return deref(self._arc).ilabel + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_3Arc_6ilabel_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_3Arc_6ilabel_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_3Arc_6ilabel___get__(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_3Arc_6ilabel___get__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "pywrapfst.pyx":2927 + * + * def __get__(self): + * return deref(self._arc).ilabel # <<<<<<<<<<<<<< + * + * def __set__(self, int64 value): + */ + __Pyx_XDECREF(__pyx_r); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_arc"); + __PYX_ERR(0, 2927, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_PyInt_From_int64_t((*__pyx_v_self->_arc).ilabel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2927, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":2926 + * property ilabel: + * + * def __get__(self): # <<<<<<<<<<<<<< + * return deref(self._arc).ilabel + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Arc.ilabel.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2929 + * return deref(self._arc).ilabel + * + * def __set__(self, int64 value): # <<<<<<<<<<<<<< + * deref(self._arc).ilabel = value + * + */ + +/* Python wrapper */ +static int __pyx_pw_9pywrapfst_3Arc_6ilabel_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_9pywrapfst_3Arc_6ilabel_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + __pyx_t_10basictypes_int64 __pyx_v_value; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_int64_t(__pyx_arg_value); if (unlikely((__pyx_v_value == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2929, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.Arc.ilabel.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_3Arc_6ilabel_2__set__(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self), ((__pyx_t_10basictypes_int64)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pywrapfst_3Arc_6ilabel_2__set__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + + /* "pywrapfst.pyx":2930 + * + * def __set__(self, int64 value): + * deref(self._arc).ilabel = value # <<<<<<<<<<<<<< + * + * property olabel: + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_arc"); + __PYX_ERR(0, 2930, __pyx_L1_error) + } + (*__pyx_v_self->_arc).ilabel = __pyx_v_value; + + /* "pywrapfst.pyx":2929 + * return deref(self._arc).ilabel + * + * def __set__(self, int64 value): # <<<<<<<<<<<<<< + * deref(self._arc).ilabel = value + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst.Arc.ilabel.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2934 + * property olabel: + * + * def __get__(self): # <<<<<<<<<<<<<< + * return deref(self._arc).olabel + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_3Arc_6olabel_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_3Arc_6olabel_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_3Arc_6olabel___get__(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_3Arc_6olabel___get__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "pywrapfst.pyx":2935 + * + * def __get__(self): + * return deref(self._arc).olabel # <<<<<<<<<<<<<< + * + * def __set__(self, int64 value): + */ + __Pyx_XDECREF(__pyx_r); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_arc"); + __PYX_ERR(0, 2935, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_PyInt_From_int64_t((*__pyx_v_self->_arc).olabel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2935, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":2934 + * property olabel: + * + * def __get__(self): # <<<<<<<<<<<<<< + * return deref(self._arc).olabel + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Arc.olabel.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2937 + * return deref(self._arc).olabel + * + * def __set__(self, int64 value): # <<<<<<<<<<<<<< + * deref(self._arc).olabel = value + * + */ + +/* Python wrapper */ +static int __pyx_pw_9pywrapfst_3Arc_6olabel_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_9pywrapfst_3Arc_6olabel_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + __pyx_t_10basictypes_int64 __pyx_v_value; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_int64_t(__pyx_arg_value); if (unlikely((__pyx_v_value == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2937, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.Arc.olabel.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_3Arc_6olabel_2__set__(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self), ((__pyx_t_10basictypes_int64)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pywrapfst_3Arc_6olabel_2__set__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + + /* "pywrapfst.pyx":2938 + * + * def __set__(self, int64 value): + * deref(self._arc).olabel = value # <<<<<<<<<<<<<< + * + * property weight: + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_arc"); + __PYX_ERR(0, 2938, __pyx_L1_error) + } + (*__pyx_v_self->_arc).olabel = __pyx_v_value; + + /* "pywrapfst.pyx":2937 + * return deref(self._arc).olabel + * + * def __set__(self, int64 value): # <<<<<<<<<<<<<< + * deref(self._arc).olabel = value + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst.Arc.olabel.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2942 + * property weight: + * + * def __get__(self): # <<<<<<<<<<<<<< + * cdef Weight weight = Weight.__new__(Weight) + * weight._weight.reset(new fst.WeightClass(deref(self._arc).weight)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_3Arc_6weight_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_3Arc_6weight_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_3Arc_6weight___get__(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_3Arc_6weight___get__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self) { + struct __pyx_obj_9pywrapfst_Weight *__pyx_v_weight = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "pywrapfst.pyx":2943 + * + * def __get__(self): + * cdef Weight weight = Weight.__new__(Weight) # <<<<<<<<<<<<<< + * weight._weight.reset(new fst.WeightClass(deref(self._arc).weight)) + * return weight + */ + __pyx_t_1 = __pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2943, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_Weight)))) __PYX_ERR(0, 2943, __pyx_L1_error) + __pyx_v_weight = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2944 + * def __get__(self): + * cdef Weight weight = Weight.__new__(Weight) + * weight._weight.reset(new fst.WeightClass(deref(self._arc).weight)) # <<<<<<<<<<<<<< + * return weight + * + */ + if (unlikely(((PyObject *)__pyx_v_weight) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 2944, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_arc"); + __PYX_ERR(0, 2944, __pyx_L1_error) + } + __pyx_v_weight->_weight.reset(new fst::script::WeightClass((*__pyx_v_self->_arc).weight)); + + /* "pywrapfst.pyx":2945 + * cdef Weight weight = Weight.__new__(Weight) + * weight._weight.reset(new fst.WeightClass(deref(self._arc).weight)) + * return weight # <<<<<<<<<<<<<< + * + * def __set__(self, weight): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_weight)); + __pyx_r = ((PyObject *)__pyx_v_weight); + goto __pyx_L0; + + /* "pywrapfst.pyx":2942 + * property weight: + * + * def __get__(self): # <<<<<<<<<<<<<< + * cdef Weight weight = Weight.__new__(Weight) + * weight._weight.reset(new fst.WeightClass(deref(self._arc).weight)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Arc.weight.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_weight); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2947 + * return weight + * + * def __set__(self, weight): # <<<<<<<<<<<<<< + * deref(self._arc).weight = _get_WeightClass_or_One(b"tropical", weight) + * + */ + +/* Python wrapper */ +static int __pyx_pw_9pywrapfst_3Arc_6weight_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_weight); /*proto*/ +static int __pyx_pw_9pywrapfst_3Arc_6weight_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_weight) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_3Arc_6weight_2__set__(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self), ((PyObject *)__pyx_v_weight)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pywrapfst_3Arc_6weight_2__set__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, PyObject *__pyx_v_weight) { + int __pyx_r; + __Pyx_RefNannyDeclarations + std::string __pyx_t_1; + fst::script::WeightClass __pyx_t_2; + __Pyx_RefNannySetupContext("__set__", 0); + + /* "pywrapfst.pyx":2948 + * + * def __set__(self, weight): + * deref(self._arc).weight = _get_WeightClass_or_One(b"tropical", weight) # <<<<<<<<<<<<<< + * + * property nextstate: + */ + __pyx_t_1 = __pyx_convert_string_from_py_std__in_string(__pyx_n_b_tropical); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2948, __pyx_L1_error) + __pyx_t_2 = __pyx_f_9pywrapfst__get_WeightClass_or_One(__pyx_t_1, __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2948, __pyx_L1_error) + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_arc"); + __PYX_ERR(0, 2948, __pyx_L1_error) + } + (*__pyx_v_self->_arc).weight = __pyx_t_2; + + /* "pywrapfst.pyx":2947 + * return weight + * + * def __set__(self, weight): # <<<<<<<<<<<<<< + * deref(self._arc).weight = _get_WeightClass_or_One(b"tropical", weight) + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst.Arc.weight.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2952 + * property nextstate: + * + * def __get__(self): # <<<<<<<<<<<<<< + * return deref(self._arc).nextstate + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_3Arc_9nextstate_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_3Arc_9nextstate_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_3Arc_9nextstate___get__(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_3Arc_9nextstate___get__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "pywrapfst.pyx":2953 + * + * def __get__(self): + * return deref(self._arc).nextstate # <<<<<<<<<<<<<< + * + * def __set__(self, int64 value): + */ + __Pyx_XDECREF(__pyx_r); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_arc"); + __PYX_ERR(0, 2953, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_PyInt_From_int64_t((*__pyx_v_self->_arc).nextstate); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2953, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":2952 + * property nextstate: + * + * def __get__(self): # <<<<<<<<<<<<<< + * return deref(self._arc).nextstate + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Arc.nextstate.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2955 + * return deref(self._arc).nextstate + * + * def __set__(self, int64 value): # <<<<<<<<<<<<<< + * deref(self._arc).nextstate = value + * + */ + +/* Python wrapper */ +static int __pyx_pw_9pywrapfst_3Arc_9nextstate_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_9pywrapfst_3Arc_9nextstate_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + __pyx_t_10basictypes_int64 __pyx_v_value; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_int64_t(__pyx_arg_value); if (unlikely((__pyx_v_value == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2955, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.Arc.nextstate.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_3Arc_9nextstate_2__set__(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self), ((__pyx_t_10basictypes_int64)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pywrapfst_3Arc_9nextstate_2__set__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + + /* "pywrapfst.pyx":2956 + * + * def __set__(self, int64 value): + * deref(self._arc).nextstate = value # <<<<<<<<<<<<<< + * + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_arc"); + __PYX_ERR(0, 2956, __pyx_L1_error) + } + (*__pyx_v_self->_arc).nextstate = __pyx_v_value; + + /* "pywrapfst.pyx":2955 + * return deref(self._arc).nextstate + * + * def __set__(self, int64 value): # <<<<<<<<<<<<<< + * deref(self._arc).nextstate = value + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst.Arc.nextstate.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._arc cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_3Arc_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_3Arc_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_3Arc_6__reduce_cython__(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_3Arc_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._arc cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._arc cannot be converted to a Python object for pickling") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__57, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._arc cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Arc.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._arc cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._arc cannot be converted to a Python object for pickling") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_3Arc_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_3Arc_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_3Arc_8__setstate_cython__(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_3Arc_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError("self._arc cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._arc cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__58, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._arc cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._arc cannot be converted to a Python object for pickling") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Arc.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2959 + * + * + * cdef Arc _init_Arc(const fst.ArcClass &arc): # <<<<<<<<<<<<<< + * cdef Weight weight = Weight.__new__(Weight) + * weight._weight.reset(new fst.WeightClass(arc.weight)) + */ + +static struct __pyx_obj_9pywrapfst_Arc *__pyx_f_9pywrapfst__init_Arc(fst::script::ArcClass const &__pyx_v_arc) { + struct __pyx_obj_9pywrapfst_Weight *__pyx_v_weight = 0; + struct __pyx_obj_9pywrapfst_Arc *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("_init_Arc", 0); + + /* "pywrapfst.pyx":2960 + * + * cdef Arc _init_Arc(const fst.ArcClass &arc): + * cdef Weight weight = Weight.__new__(Weight) # <<<<<<<<<<<<<< + * weight._weight.reset(new fst.WeightClass(arc.weight)) + * return Arc(arc.ilabel, arc.olabel, weight, arc.nextstate) + */ + __pyx_t_1 = __pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2960, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_Weight)))) __PYX_ERR(0, 2960, __pyx_L1_error) + __pyx_v_weight = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2961 + * cdef Arc _init_Arc(const fst.ArcClass &arc): + * cdef Weight weight = Weight.__new__(Weight) + * weight._weight.reset(new fst.WeightClass(arc.weight)) # <<<<<<<<<<<<<< + * return Arc(arc.ilabel, arc.olabel, weight, arc.nextstate) + * + */ + if (unlikely(((PyObject *)__pyx_v_weight) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); + __PYX_ERR(0, 2961, __pyx_L1_error) + } + __pyx_v_weight->_weight.reset(new fst::script::WeightClass(__pyx_v_arc.weight)); + + /* "pywrapfst.pyx":2962 + * cdef Weight weight = Weight.__new__(Weight) + * weight._weight.reset(new fst.WeightClass(arc.weight)) + * return Arc(arc.ilabel, arc.olabel, weight, arc.nextstate) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_v_arc.ilabel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2962, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_From_int64_t(__pyx_v_arc.olabel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2962, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_v_arc.nextstate); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2962, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2962, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2); + __Pyx_INCREF(((PyObject *)__pyx_v_weight)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_weight)); + PyTuple_SET_ITEM(__pyx_t_4, 2, ((PyObject *)__pyx_v_weight)); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_t_3); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pywrapfst_Arc), __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2962, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = ((struct __pyx_obj_9pywrapfst_Arc *)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":2959 + * + * + * cdef Arc _init_Arc(const fst.ArcClass &arc): # <<<<<<<<<<<<<< + * cdef Weight weight = Weight.__new__(Weight) + * weight._weight.reset(new fst.WeightClass(arc.weight)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pywrapfst._init_Arc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_weight); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2973 + * """ + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "".format(id(self)) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_1__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_1__repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator___repr__(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator___repr__(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "pywrapfst.pyx":2974 + * + * def __repr__(self): + * return "".format(id(self)) # <<<<<<<<<<<<<< + * + * def __init__(self, _Fst ifst, int64 state): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_ArcIterator_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2974, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2974, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self)); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2974, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2974, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2974, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2974, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2974, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2974, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":2973 + * """ + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "".format(id(self)) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pywrapfst.ArcIterator.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2976 + * return "".format(id(self)) + * + * def __init__(self, _Fst ifst, int64 state): # <<<<<<<<<<<<<< + * if not ifst._fst.get().ValidStateId(state): + * raise FstIndexError("State index out of range") + */ + +/* Python wrapper */ +static int __pyx_pw_9pywrapfst_11ArcIterator_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_9pywrapfst_11ArcIterator_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0; + __pyx_t_10basictypes_int64 __pyx_v_state; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_state,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); __PYX_ERR(0, 2976, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 2976, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_ifst = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]); + __pyx_v_state = __Pyx_PyInt_As_int64_t(values[1]); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2976, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2976, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.ArcIterator.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst), __pyx_ptype_9pywrapfst__Fst, 1, "ifst", 0))) __PYX_ERR(0, 2976, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator_2__init__(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self), __pyx_v_ifst, __pyx_v_state); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pywrapfst_11ArcIterator_2__init__(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, __pyx_t_10basictypes_int64 __pyx_v_state) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + std::shared_ptr __pyx_t_4; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "pywrapfst.pyx":2977 + * + * def __init__(self, _Fst ifst, int64 state): + * if not ifst._fst.get().ValidStateId(state): # <<<<<<<<<<<<<< + * raise FstIndexError("State index out of range") + * # Makes copy of the shared_ptr, potentially extending the FST's lifetime. + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 2977, __pyx_L1_error) + } + __pyx_t_1 = ((!(__pyx_v_ifst->_fst.get()->ValidStateId(__pyx_v_state) != 0)) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":2978 + * def __init__(self, _Fst ifst, int64 state): + * if not ifst._fst.get().ValidStateId(state): + * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< + * # Makes copy of the shared_ptr, potentially extending the FST's lifetime. + * self._fst = ifst._fst + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2978, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__59, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2978, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 2978, __pyx_L1_error) + + /* "pywrapfst.pyx":2977 + * + * def __init__(self, _Fst ifst, int64 state): + * if not ifst._fst.get().ValidStateId(state): # <<<<<<<<<<<<<< + * raise FstIndexError("State index out of range") + * # Makes copy of the shared_ptr, potentially extending the FST's lifetime. + */ + } + + /* "pywrapfst.pyx":2980 + * raise FstIndexError("State index out of range") + * # Makes copy of the shared_ptr, potentially extending the FST's lifetime. + * self._fst = ifst._fst # <<<<<<<<<<<<<< + * self._aiter.reset(new fst.ArcIteratorClass(deref(self._fst), state)) + * + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 2980, __pyx_L1_error) + } + __pyx_t_4 = __pyx_v_ifst->_fst; + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 2980, __pyx_L1_error) + } + __pyx_v_self->_fst = __pyx_t_4; + + /* "pywrapfst.pyx":2981 + * # Makes copy of the shared_ptr, potentially extending the FST's lifetime. + * self._fst = ifst._fst + * self._aiter.reset(new fst.ArcIteratorClass(deref(self._fst), state)) # <<<<<<<<<<<<<< + * + * # This just registers this class as a possible iterator. + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); + __PYX_ERR(0, 2981, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 2981, __pyx_L1_error) + } + __pyx_v_self->_aiter.reset(new fst::script::ArcIteratorClass((*__pyx_v_self->_fst), __pyx_v_state)); + + /* "pywrapfst.pyx":2976 + * return "".format(id(self)) + * + * def __init__(self, _Fst ifst, int64 state): # <<<<<<<<<<<<<< + * if not ifst._fst.get().ValidStateId(state): + * raise FstIndexError("State index out of range") + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pywrapfst.ArcIterator.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2984 + * + * # This just registers this class as a possible iterator. + * def __iter__(self): # <<<<<<<<<<<<<< + * return self + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_5__iter__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_5__iter__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator_4__iter__(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_4__iter__(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__iter__", 0); + + /* "pywrapfst.pyx":2985 + * # This just registers this class as a possible iterator. + * def __iter__(self): + * return self # <<<<<<<<<<<<<< + * + * # Magic method used to get a Pythonic API out of the C++ API. + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":2984 + * + * # This just registers this class as a possible iterator. + * def __iter__(self): # <<<<<<<<<<<<<< + * return self + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2988 + * + * # Magic method used to get a Pythonic API out of the C++ API. + * def __next__(self): # <<<<<<<<<<<<<< + * if self.done(): + * raise StopIteration + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_7__next__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_7__next__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__next__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator_6__next__(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_6__next__(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self) { + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__next__", 0); + + /* "pywrapfst.pyx":2989 + * # Magic method used to get a Pythonic API out of the C++ API. + * def __next__(self): + * if self.done(): # <<<<<<<<<<<<<< + * raise StopIteration + * result = self.value() + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "done"); + __PYX_ERR(0, 2989, __pyx_L1_error) + } + __pyx_t_1 = (((struct __pyx_vtabstruct_9pywrapfst_ArcIterator *)__pyx_v_self->__pyx_vtab)->done(__pyx_v_self, 0) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":2990 + * def __next__(self): + * if self.done(): + * raise StopIteration # <<<<<<<<<<<<<< + * result = self.value() + * self.next() + */ + __Pyx_Raise(__pyx_builtin_StopIteration, 0, 0, 0); + __PYX_ERR(0, 2990, __pyx_L1_error) + + /* "pywrapfst.pyx":2989 + * # Magic method used to get a Pythonic API out of the C++ API. + * def __next__(self): + * if self.done(): # <<<<<<<<<<<<<< + * raise StopIteration + * result = self.value() + */ + } + + /* "pywrapfst.pyx":2991 + * if self.done(): + * raise StopIteration + * result = self.value() # <<<<<<<<<<<<<< + * self.next() + * return result + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "value"); + __PYX_ERR(0, 2991, __pyx_L1_error) + } + __pyx_t_2 = ((struct __pyx_vtabstruct_9pywrapfst_ArcIterator *)__pyx_v_self->__pyx_vtab)->value(__pyx_v_self, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2991, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_result = __pyx_t_2; + __pyx_t_2 = 0; + + /* "pywrapfst.pyx":2992 + * raise StopIteration + * result = self.value() + * self.next() # <<<<<<<<<<<<<< + * return result + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "next"); + __PYX_ERR(0, 2992, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst_ArcIterator *)__pyx_v_self->__pyx_vtab)->next(__pyx_v_self, 0); + + /* "pywrapfst.pyx":2993 + * result = self.value() + * self.next() + * return result # <<<<<<<<<<<<<< + * + * cpdef bool done(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "pywrapfst.pyx":2988 + * + * # Magic method used to get a Pythonic API out of the C++ API. + * def __next__(self): # <<<<<<<<<<<<<< + * if self.done(): + * raise StopIteration + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pywrapfst.ArcIterator.__next__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":2995 + * return result + * + * cpdef bool done(self): # <<<<<<<<<<<<<< + * """ + * done(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_9done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static bool __pyx_f_9pywrapfst_11ArcIterator_done(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch) { + bool __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + bool __pyx_t_5; + __Pyx_RefNannySetupContext("done", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_done); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2995, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_9done)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2995, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2995, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2995, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":3004 + * True if the iterator is exhausted, False otherwise. + * """ + * return self._aiter.get().Done() # <<<<<<<<<<<<<< + * + * cpdef uint32 flags(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); + __PYX_ERR(0, 3004, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_aiter.get()->Done(); + goto __pyx_L0; + + /* "pywrapfst.pyx":2995 + * return result + * + * cpdef bool done(self): # <<<<<<<<<<<<<< + * """ + * done(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.ArcIterator.done", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_9done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_11ArcIterator_8done[] = "\n done(self)\n\n Indicates whether the iterator is exhausted or not.\n\n Returns:\n True if the iterator is exhausted, False otherwise.\n "; +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_9done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("done (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator_8done(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_8done(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("done", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_9pywrapfst_11ArcIterator_done(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2995, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.ArcIterator.done", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3006 + * return self._aiter.get().Done() + * + * cpdef uint32 flags(self): # <<<<<<<<<<<<<< + * """ + * flags(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_11flags(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static __pyx_t_10basictypes_uint32 __pyx_f_9pywrapfst_11ArcIterator_flags(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch) { + __pyx_t_10basictypes_uint32 __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __pyx_t_10basictypes_uint32 __pyx_t_5; + __Pyx_RefNannySetupContext("flags", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3006, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_11flags)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3006, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3006, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyInt_As_uint32_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3006, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":3015 + * The current iterator behavioral flags as an integer. + * """ + * return self._aiter.get().Flags() # <<<<<<<<<<<<<< + * + * cpdef void next(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); + __PYX_ERR(0, 3015, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_aiter.get()->Flags(); + goto __pyx_L0; + + /* "pywrapfst.pyx":3006 + * return self._aiter.get().Done() + * + * cpdef uint32 flags(self): # <<<<<<<<<<<<<< + * """ + * flags(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.ArcIterator.flags", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_11flags(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_11ArcIterator_10flags[] = "\n flags(self)\n\n Returns the current iterator behavioral flags.\n\n Returns:\n The current iterator behavioral flags as an integer.\n "; +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_11flags(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("flags (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator_10flags(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_10flags(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("flags", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_uint32_t(__pyx_f_9pywrapfst_11ArcIterator_flags(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3006, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.ArcIterator.flags", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3017 + * return self._aiter.get().Flags() + * + * cpdef void next(self): # <<<<<<<<<<<<<< + * """ + * next(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_13next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static void __pyx_f_9pywrapfst_11ArcIterator_next(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("next", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_next); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3017, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_13next)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3017, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3017, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":3023 + * Advances the iterator. + * """ + * self._aiter.get().Next() # <<<<<<<<<<<<<< + * + * cpdef size_t position(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); + __PYX_ERR(0, 3023, __pyx_L1_error) + } + __pyx_v_self->_aiter.get()->Next(); + + /* "pywrapfst.pyx":3017 + * return self._aiter.get().Flags() + * + * cpdef void next(self): # <<<<<<<<<<<<<< + * """ + * next(self) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.ArcIterator.next", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_13next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_11ArcIterator_12next[] = "\n next(self)\n\n Advances the iterator.\n "; +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_13next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("next (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator_12next(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_12next(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("next", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_11ArcIterator_next(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3017, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.ArcIterator.next", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3025 + * self._aiter.get().Next() + * + * cpdef size_t position(self): # <<<<<<<<<<<<<< + * """ + * position(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_15position(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static size_t __pyx_f_9pywrapfst_11ArcIterator_position(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch) { + size_t __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + __Pyx_RefNannySetupContext("position", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_position); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3025, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_15position)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3025, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3025, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_5 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 3025, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":3034 + * The iterator's position, expressed as an integer. + * """ + * return self._aiter.get().Position() # <<<<<<<<<<<<<< + * + * cpdef void reset(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); + __PYX_ERR(0, 3034, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_aiter.get()->Position(); + goto __pyx_L0; + + /* "pywrapfst.pyx":3025 + * self._aiter.get().Next() + * + * cpdef size_t position(self): # <<<<<<<<<<<<<< + * """ + * position(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.ArcIterator.position", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_15position(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_11ArcIterator_14position[] = "\n position(self)\n\n Returns the position of the iterator.\n\n Returns:\n The iterator's position, expressed as an integer.\n "; +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_15position(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("position (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator_14position(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_14position(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("position", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_f_9pywrapfst_11ArcIterator_position(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3025, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.ArcIterator.position", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3036 + * return self._aiter.get().Position() + * + * cpdef void reset(self): # <<<<<<<<<<<<<< + * """ + * reset(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_17reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static void __pyx_f_9pywrapfst_11ArcIterator_reset(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("reset", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_reset); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3036, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_17reset)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3036, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3036, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":3042 + * Resets the iterator to the initial position. + * """ + * self._aiter.get().Reset() # <<<<<<<<<<<<<< + * + * cpdef void seek(self, size_t a): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); + __PYX_ERR(0, 3042, __pyx_L1_error) + } + __pyx_v_self->_aiter.get()->Reset(); + + /* "pywrapfst.pyx":3036 + * return self._aiter.get().Position() + * + * cpdef void reset(self): # <<<<<<<<<<<<<< + * """ + * reset(self) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.ArcIterator.reset", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_17reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_11ArcIterator_16reset[] = "\n reset(self)\n\n Resets the iterator to the initial position.\n "; +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_17reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("reset (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator_16reset(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_16reset(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("reset", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_11ArcIterator_reset(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3036, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.ArcIterator.reset", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3044 + * self._aiter.get().Reset() + * + * cpdef void seek(self, size_t a): # <<<<<<<<<<<<<< + * """ + * seek(self, a) + */ + +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_19seek(PyObject *__pyx_v_self, PyObject *__pyx_arg_a); /*proto*/ +static void __pyx_f_9pywrapfst_11ArcIterator_seek(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, size_t __pyx_v_a, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + __Pyx_RefNannySetupContext("seek", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_seek); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3044, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_19seek)) { + __pyx_t_3 = __Pyx_PyInt_FromSize_t(__pyx_v_a); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3044, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3044, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3044, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3044, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3044, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3044, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":3053 + * a: The position to seek to. + * """ + * self._aiter.get().Seek(a) # <<<<<<<<<<<<<< + * + * cpdef void set_flags(self, uint32 flags, uint32 mask): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); + __PYX_ERR(0, 3053, __pyx_L1_error) + } + __pyx_v_self->_aiter.get()->Seek(__pyx_v_a); + + /* "pywrapfst.pyx":3044 + * self._aiter.get().Reset() + * + * cpdef void seek(self, size_t a): # <<<<<<<<<<<<<< + * """ + * seek(self, a) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_WriteUnraisable("pywrapfst.ArcIterator.seek", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_19seek(PyObject *__pyx_v_self, PyObject *__pyx_arg_a); /*proto*/ +static char __pyx_doc_9pywrapfst_11ArcIterator_18seek[] = "\n seek(self, a)\n\n Advance the iterator to a new position.\n\n Args:\n a: The position to seek to.\n "; +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_19seek(PyObject *__pyx_v_self, PyObject *__pyx_arg_a) { + size_t __pyx_v_a; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("seek (wrapper)", 0); + assert(__pyx_arg_a); { + __pyx_v_a = __Pyx_PyInt_As_size_t(__pyx_arg_a); if (unlikely((__pyx_v_a == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 3044, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.ArcIterator.seek", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator_18seek(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self), ((size_t)__pyx_v_a)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_18seek(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, size_t __pyx_v_a) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("seek", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_11ArcIterator_seek(__pyx_v_self, __pyx_v_a, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3044, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.ArcIterator.seek", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3055 + * self._aiter.get().Seek(a) + * + * cpdef void set_flags(self, uint32 flags, uint32 mask): # <<<<<<<<<<<<<< + * """ + * set_flags(self, flags, mask) + */ + +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_21set_flags(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static void __pyx_f_9pywrapfst_11ArcIterator_set_flags(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, __pyx_t_10basictypes_uint32 __pyx_v_flags, __pyx_t_10basictypes_uint32 __pyx_v_mask, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("set_flags", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3055, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_21set_flags)) { + __pyx_t_3 = __Pyx_PyInt_From_uint32_t(__pyx_v_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3055, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_uint32_t(__pyx_v_mask); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3055, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_5 = __pyx_t_1; __pyx_t_6 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3055, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3055, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3055, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_6) { + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; + } + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_4); + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3055, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":3065 + * mask: A mask to be applied to the `flags` argument before setting them. + * """ + * self._aiter.get().SetFlags(flags, mask) # <<<<<<<<<<<<<< + * + * cpdef object value(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); + __PYX_ERR(0, 3065, __pyx_L1_error) + } + __pyx_v_self->_aiter.get()->SetFlags(__pyx_v_flags, __pyx_v_mask); + + /* "pywrapfst.pyx":3055 + * self._aiter.get().Seek(a) + * + * cpdef void set_flags(self, uint32 flags, uint32 mask): # <<<<<<<<<<<<<< + * """ + * set_flags(self, flags, mask) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_WriteUnraisable("pywrapfst.ArcIterator.set_flags", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_21set_flags(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_11ArcIterator_20set_flags[] = "\n set_flags(self, flags, mask)\n\n Sets the current iterator behavioral flags.\n\n Args:\n flags: The properties to be set.\n mask: A mask to be applied to the `flags` argument before setting them.\n "; +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_21set_flags(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + __pyx_t_10basictypes_uint32 __pyx_v_flags; + __pyx_t_10basictypes_uint32 __pyx_v_mask; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_flags (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_flags,&__pyx_n_s_mask,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mask)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("set_flags", 1, 2, 2, 1); __PYX_ERR(0, 3055, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_flags") < 0)) __PYX_ERR(0, 3055, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_flags = __Pyx_PyInt_As_uint32_t(values[0]); if (unlikely((__pyx_v_flags == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3055, __pyx_L3_error) + __pyx_v_mask = __Pyx_PyInt_As_uint32_t(values[1]); if (unlikely((__pyx_v_mask == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3055, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("set_flags", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3055, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.ArcIterator.set_flags", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator_20set_flags(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self), __pyx_v_flags, __pyx_v_mask); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_20set_flags(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, __pyx_t_10basictypes_uint32 __pyx_v_flags, __pyx_t_10basictypes_uint32 __pyx_v_mask) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("set_flags", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_11ArcIterator_set_flags(__pyx_v_self, __pyx_v_flags, __pyx_v_mask, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3055, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.ArcIterator.set_flags", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3067 + * self._aiter.get().SetFlags(flags, mask) + * + * cpdef object value(self): # <<<<<<<<<<<<<< + * """ + * value(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_23value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_f_9pywrapfst_11ArcIterator_value(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("value", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3067, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_23value)) { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3067, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3067, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":3073 + * Returns the current arc. + * """ + * return _init_Arc(self._aiter.get().Value()) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); + __PYX_ERR(0, 3073, __pyx_L1_error) + } + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_Arc(__pyx_v_self->_aiter.get()->Value())); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3073, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":3067 + * self._aiter.get().SetFlags(flags, mask) + * + * cpdef object value(self): # <<<<<<<<<<<<<< + * """ + * value(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pywrapfst.ArcIterator.value", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_23value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_11ArcIterator_22value[] = "\n value(self)\n\n Returns the current arc.\n "; +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_23value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("value (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator_22value(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_22value(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("value", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pywrapfst_11ArcIterator_value(__pyx_v_self, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3067, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.ArcIterator.value", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._aiter,self._fst cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_25__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_25__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator_24__reduce_cython__(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_24__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._aiter,self._fst cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._aiter,self._fst cannot be converted to a Python object for pickling") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__60, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._aiter,self._fst cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.ArcIterator.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._aiter,self._fst cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._aiter,self._fst cannot be converted to a Python object for pickling") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_27__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_27__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator_26__setstate_cython__(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_26__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError("self._aiter,self._fst cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._aiter,self._fst cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._aiter,self._fst cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._aiter,self._fst cannot be converted to a Python object for pickling") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.ArcIterator.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3085 + * """ + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "".format(id(self)) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_1__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_1__repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_18MutableArcIterator___repr__(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator___repr__(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "pywrapfst.pyx":3086 + * + * def __repr__(self): + * return "".format(id(self)) # <<<<<<<<<<<<<< + * + * def __init__(self, _MutableFst ifst, int64 state): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_MutableArcIterator_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3086, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3086, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self)); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3086, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3086, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3086, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3086, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3086, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3086, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":3085 + * """ + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "".format(id(self)) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pywrapfst.MutableArcIterator.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3088 + * return "".format(id(self)) + * + * def __init__(self, _MutableFst ifst, int64 state): # <<<<<<<<<<<<<< + * if not ifst._fst.get().ValidStateId(state): + * raise FstIndexError("State index out of range") + */ + +/* Python wrapper */ +static int __pyx_pw_9pywrapfst_18MutableArcIterator_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_9pywrapfst_18MutableArcIterator_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_ifst = 0; + __pyx_t_10basictypes_int64 __pyx_v_state; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_state,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); __PYX_ERR(0, 3088, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 3088, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_ifst = ((struct __pyx_obj_9pywrapfst__MutableFst *)values[0]); + __pyx_v_state = __Pyx_PyInt_As_int64_t(values[1]); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3088, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3088, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.MutableArcIterator.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst), __pyx_ptype_9pywrapfst__MutableFst, 1, "ifst", 0))) __PYX_ERR(0, 3088, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_18MutableArcIterator_2__init__(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self), __pyx_v_ifst, __pyx_v_state); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pywrapfst_18MutableArcIterator_2__init__(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_ifst, __pyx_t_10basictypes_int64 __pyx_v_state) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + std::shared_ptr __pyx_t_4; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "pywrapfst.pyx":3089 + * + * def __init__(self, _MutableFst ifst, int64 state): + * if not ifst._fst.get().ValidStateId(state): # <<<<<<<<<<<<<< + * raise FstIndexError("State index out of range") + * # Makes copy of the shared_ptr, potentially extending the FST's lifetime. + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3089, __pyx_L1_error) + } + __pyx_t_1 = ((!(__pyx_v_ifst->__pyx_base._fst.get()->ValidStateId(__pyx_v_state) != 0)) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":3090 + * def __init__(self, _MutableFst ifst, int64 state): + * if not ifst._fst.get().ValidStateId(state): + * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< + * # Makes copy of the shared_ptr, potentially extending the FST's lifetime. + * self._mfst = ifst._mfst + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3090, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3090, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 3090, __pyx_L1_error) + + /* "pywrapfst.pyx":3089 + * + * def __init__(self, _MutableFst ifst, int64 state): + * if not ifst._fst.get().ValidStateId(state): # <<<<<<<<<<<<<< + * raise FstIndexError("State index out of range") + * # Makes copy of the shared_ptr, potentially extending the FST's lifetime. + */ + } + + /* "pywrapfst.pyx":3092 + * raise FstIndexError("State index out of range") + * # Makes copy of the shared_ptr, potentially extending the FST's lifetime. + * self._mfst = ifst._mfst # <<<<<<<<<<<<<< + * self._aiter.reset(new fst.MutableArcIteratorClass(ifst._mfst.get(), state)) + * + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 3092, __pyx_L1_error) + } + __pyx_t_4 = __pyx_v_ifst->_mfst; + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 3092, __pyx_L1_error) + } + __pyx_v_self->_mfst = __pyx_t_4; + + /* "pywrapfst.pyx":3093 + * # Makes copy of the shared_ptr, potentially extending the FST's lifetime. + * self._mfst = ifst._mfst + * self._aiter.reset(new fst.MutableArcIteratorClass(ifst._mfst.get(), state)) # <<<<<<<<<<<<<< + * + * cpdef bool done(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); + __PYX_ERR(0, 3093, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); + __PYX_ERR(0, 3093, __pyx_L1_error) + } + __pyx_v_self->_aiter.reset(new fst::script::MutableArcIteratorClass(__pyx_v_ifst->_mfst.get(), __pyx_v_state)); + + /* "pywrapfst.pyx":3088 + * return "".format(id(self)) + * + * def __init__(self, _MutableFst ifst, int64 state): # <<<<<<<<<<<<<< + * if not ifst._fst.get().ValidStateId(state): + * raise FstIndexError("State index out of range") + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pywrapfst.MutableArcIterator.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3095 + * self._aiter.reset(new fst.MutableArcIteratorClass(ifst._mfst.get(), state)) + * + * cpdef bool done(self): # <<<<<<<<<<<<<< + * """ + * done(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_5done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static bool __pyx_f_9pywrapfst_18MutableArcIterator_done(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch) { + bool __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + bool __pyx_t_5; + __Pyx_RefNannySetupContext("done", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_done); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3095, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_5done)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3095, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3095, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3095, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":3104 + * True if the iterator is exhausted, False otherwise. + * """ + * return self._aiter.get().Done() # <<<<<<<<<<<<<< + * + * cpdef uint32 flags(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); + __PYX_ERR(0, 3104, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_aiter.get()->Done(); + goto __pyx_L0; + + /* "pywrapfst.pyx":3095 + * self._aiter.reset(new fst.MutableArcIteratorClass(ifst._mfst.get(), state)) + * + * cpdef bool done(self): # <<<<<<<<<<<<<< + * """ + * done(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.MutableArcIterator.done", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_5done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_18MutableArcIterator_4done[] = "\n done(self)\n\n Indicates whether the iterator is exhausted or not.\n\n Returns:\n True if the iterator is exhausted, False otherwise.\n "; +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_5done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("done (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_18MutableArcIterator_4done(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_4done(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("done", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_9pywrapfst_18MutableArcIterator_done(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3095, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.MutableArcIterator.done", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3106 + * return self._aiter.get().Done() + * + * cpdef uint32 flags(self): # <<<<<<<<<<<<<< + * """ + * flags(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_7flags(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static __pyx_t_10basictypes_uint32 __pyx_f_9pywrapfst_18MutableArcIterator_flags(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch) { + __pyx_t_10basictypes_uint32 __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __pyx_t_10basictypes_uint32 __pyx_t_5; + __Pyx_RefNannySetupContext("flags", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_7flags)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3106, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3106, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyInt_As_uint32_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3106, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":3115 + * The current iterator behavioral flags as an integer. + * """ + * return self._aiter.get().Flags() # <<<<<<<<<<<<<< + * + * cpdef void next(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); + __PYX_ERR(0, 3115, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_aiter.get()->Flags(); + goto __pyx_L0; + + /* "pywrapfst.pyx":3106 + * return self._aiter.get().Done() + * + * cpdef uint32 flags(self): # <<<<<<<<<<<<<< + * """ + * flags(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.MutableArcIterator.flags", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_7flags(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_18MutableArcIterator_6flags[] = "\n flags(self)\n\n Returns the current iterator behavioral flags.\n\n Returns:\n The current iterator behavioral flags as an integer.\n "; +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_7flags(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("flags (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_18MutableArcIterator_6flags(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_6flags(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("flags", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_uint32_t(__pyx_f_9pywrapfst_18MutableArcIterator_flags(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.MutableArcIterator.flags", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3117 + * return self._aiter.get().Flags() + * + * cpdef void next(self): # <<<<<<<<<<<<<< + * """ + * next(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_9next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static void __pyx_f_9pywrapfst_18MutableArcIterator_next(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("next", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_next); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_9next)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3117, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3117, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":3123 + * Advances the iterator. + * """ + * self._aiter.get().Next() # <<<<<<<<<<<<<< + * + * cpdef size_t position(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); + __PYX_ERR(0, 3123, __pyx_L1_error) + } + __pyx_v_self->_aiter.get()->Next(); + + /* "pywrapfst.pyx":3117 + * return self._aiter.get().Flags() + * + * cpdef void next(self): # <<<<<<<<<<<<<< + * """ + * next(self) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.MutableArcIterator.next", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_9next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_18MutableArcIterator_8next[] = "\n next(self)\n\n Advances the iterator.\n "; +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_9next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("next (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_18MutableArcIterator_8next(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_8next(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("next", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_18MutableArcIterator_next(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.MutableArcIterator.next", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3125 + * self._aiter.get().Next() + * + * cpdef size_t position(self): # <<<<<<<<<<<<<< + * """ + * position(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_11position(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static size_t __pyx_f_9pywrapfst_18MutableArcIterator_position(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch) { + size_t __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + __Pyx_RefNannySetupContext("position", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_position); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_11position)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3125, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3125, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_5 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 3125, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":3134 + * The iterator's position, expressed as an integer. + * """ + * return self._aiter.get().Position() # <<<<<<<<<<<<<< + * + * cpdef void reset(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); + __PYX_ERR(0, 3134, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_aiter.get()->Position(); + goto __pyx_L0; + + /* "pywrapfst.pyx":3125 + * self._aiter.get().Next() + * + * cpdef size_t position(self): # <<<<<<<<<<<<<< + * """ + * position(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.MutableArcIterator.position", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_11position(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_18MutableArcIterator_10position[] = "\n position(self)\n\n Returns the position of the iterator.\n\n Returns:\n The iterator's position, expressed as an integer.\n "; +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_11position(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("position (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_18MutableArcIterator_10position(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_10position(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("position", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_f_9pywrapfst_18MutableArcIterator_position(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.MutableArcIterator.position", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3136 + * return self._aiter.get().Position() + * + * cpdef void reset(self): # <<<<<<<<<<<<<< + * """ + * reset(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_13reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static void __pyx_f_9pywrapfst_18MutableArcIterator_reset(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("reset", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_reset); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_13reset)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3136, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":3142 + * Resets the iterator to the initial position. + * """ + * self._aiter.get().Reset() # <<<<<<<<<<<<<< + * + * cpdef void seek(self, size_t a): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); + __PYX_ERR(0, 3142, __pyx_L1_error) + } + __pyx_v_self->_aiter.get()->Reset(); + + /* "pywrapfst.pyx":3136 + * return self._aiter.get().Position() + * + * cpdef void reset(self): # <<<<<<<<<<<<<< + * """ + * reset(self) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.MutableArcIterator.reset", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_13reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_18MutableArcIterator_12reset[] = "\n reset(self)\n\n Resets the iterator to the initial position.\n "; +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_13reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("reset (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_18MutableArcIterator_12reset(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_12reset(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("reset", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_18MutableArcIterator_reset(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.MutableArcIterator.reset", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3144 + * self._aiter.get().Reset() + * + * cpdef void seek(self, size_t a): # <<<<<<<<<<<<<< + * """ + * seek(self, a) + */ + +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_15seek(PyObject *__pyx_v_self, PyObject *__pyx_arg_a); /*proto*/ +static void __pyx_f_9pywrapfst_18MutableArcIterator_seek(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, size_t __pyx_v_a, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + __Pyx_RefNannySetupContext("seek", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_seek); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_15seek)) { + __pyx_t_3 = __Pyx_PyInt_FromSize_t(__pyx_v_a); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3144, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3144, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3144, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":3153 + * a: The position to seek to. + * """ + * self._aiter.get().Seek(a) # <<<<<<<<<<<<<< + * + * cpdef void set_flags(self, uint32 flags, uint32 mask): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); + __PYX_ERR(0, 3153, __pyx_L1_error) + } + __pyx_v_self->_aiter.get()->Seek(__pyx_v_a); + + /* "pywrapfst.pyx":3144 + * self._aiter.get().Reset() + * + * cpdef void seek(self, size_t a): # <<<<<<<<<<<<<< + * """ + * seek(self, a) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_WriteUnraisable("pywrapfst.MutableArcIterator.seek", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_15seek(PyObject *__pyx_v_self, PyObject *__pyx_arg_a); /*proto*/ +static char __pyx_doc_9pywrapfst_18MutableArcIterator_14seek[] = "\n seek(self, a)\n\n Advance the iterator to a new position.\n\n Args:\n a: The position to seek to.\n "; +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_15seek(PyObject *__pyx_v_self, PyObject *__pyx_arg_a) { + size_t __pyx_v_a; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("seek (wrapper)", 0); + assert(__pyx_arg_a); { + __pyx_v_a = __Pyx_PyInt_As_size_t(__pyx_arg_a); if (unlikely((__pyx_v_a == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 3144, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.MutableArcIterator.seek", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_18MutableArcIterator_14seek(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self), ((size_t)__pyx_v_a)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_14seek(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, size_t __pyx_v_a) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("seek", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_18MutableArcIterator_seek(__pyx_v_self, __pyx_v_a, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.MutableArcIterator.seek", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3155 + * self._aiter.get().Seek(a) + * + * cpdef void set_flags(self, uint32 flags, uint32 mask): # <<<<<<<<<<<<<< + * """ + * set_flags(self, flags, mask) + */ + +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_17set_flags(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static void __pyx_f_9pywrapfst_18MutableArcIterator_set_flags(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, __pyx_t_10basictypes_uint32 __pyx_v_flags, __pyx_t_10basictypes_uint32 __pyx_v_mask, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("set_flags", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_17set_flags)) { + __pyx_t_3 = __Pyx_PyInt_From_uint32_t(__pyx_v_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_uint32_t(__pyx_v_mask); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_5 = __pyx_t_1; __pyx_t_6 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3155, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3155, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_6) { + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; + } + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_4); + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":3165 + * mask: A mask to be applied to the `flags` argument before setting them. + * """ + * self._aiter.get().SetFlags(flags, mask) # <<<<<<<<<<<<<< + * + * cpdef void set_value(self, Arc arc): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); + __PYX_ERR(0, 3165, __pyx_L1_error) + } + __pyx_v_self->_aiter.get()->SetFlags(__pyx_v_flags, __pyx_v_mask); + + /* "pywrapfst.pyx":3155 + * self._aiter.get().Seek(a) + * + * cpdef void set_flags(self, uint32 flags, uint32 mask): # <<<<<<<<<<<<<< + * """ + * set_flags(self, flags, mask) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_WriteUnraisable("pywrapfst.MutableArcIterator.set_flags", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_17set_flags(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_18MutableArcIterator_16set_flags[] = "\n set_flags(self, flags, mask)\n\n Sets the current iterator behavioral flags.\n\n Args:\n flags: The properties to be set.\n mask: A mask to be applied to the `flags` argument before setting them.\n "; +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_17set_flags(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + __pyx_t_10basictypes_uint32 __pyx_v_flags; + __pyx_t_10basictypes_uint32 __pyx_v_mask; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_flags (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_flags,&__pyx_n_s_mask,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mask)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("set_flags", 1, 2, 2, 1); __PYX_ERR(0, 3155, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_flags") < 0)) __PYX_ERR(0, 3155, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_flags = __Pyx_PyInt_As_uint32_t(values[0]); if (unlikely((__pyx_v_flags == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3155, __pyx_L3_error) + __pyx_v_mask = __Pyx_PyInt_As_uint32_t(values[1]); if (unlikely((__pyx_v_mask == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3155, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("set_flags", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3155, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.MutableArcIterator.set_flags", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_18MutableArcIterator_16set_flags(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self), __pyx_v_flags, __pyx_v_mask); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_16set_flags(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, __pyx_t_10basictypes_uint32 __pyx_v_flags, __pyx_t_10basictypes_uint32 __pyx_v_mask) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("set_flags", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_18MutableArcIterator_set_flags(__pyx_v_self, __pyx_v_flags, __pyx_v_mask, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.MutableArcIterator.set_flags", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3167 + * self._aiter.get().SetFlags(flags, mask) + * + * cpdef void set_value(self, Arc arc): # <<<<<<<<<<<<<< + * """ + * set_value(self, arc) + */ + +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_19set_value(PyObject *__pyx_v_self, PyObject *__pyx_v_arc); /*proto*/ +static void __pyx_f_9pywrapfst_18MutableArcIterator_set_value(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("set_value", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_19set_value)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_arc)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, ((PyObject *)__pyx_v_arc)}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3167, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, ((PyObject *)__pyx_v_arc)}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3167, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(((PyObject *)__pyx_v_arc)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_arc)); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, ((PyObject *)__pyx_v_arc)); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":3176 + * arc: The arc to replace the current arc with. + * """ + * self._aiter.get().SetValue(deref(arc._arc)) # <<<<<<<<<<<<<< + * + * cpdef object value(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); + __PYX_ERR(0, 3176, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_arc) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_arc"); + __PYX_ERR(0, 3176, __pyx_L1_error) + } + __pyx_v_self->_aiter.get()->SetValue((*__pyx_v_arc->_arc)); + + /* "pywrapfst.pyx":3167 + * self._aiter.get().SetFlags(flags, mask) + * + * cpdef void set_value(self, Arc arc): # <<<<<<<<<<<<<< + * """ + * set_value(self, arc) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_WriteUnraisable("pywrapfst.MutableArcIterator.set_value", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_19set_value(PyObject *__pyx_v_self, PyObject *__pyx_v_arc); /*proto*/ +static char __pyx_doc_9pywrapfst_18MutableArcIterator_18set_value[] = "\n set_value(self, arc)\n\n Replace the current arc with a new arc.\n\n Args:\n arc: The arc to replace the current arc with.\n "; +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_19set_value(PyObject *__pyx_v_self, PyObject *__pyx_v_arc) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_value (wrapper)", 0); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_arc), __pyx_ptype_9pywrapfst_Arc, 1, "arc", 0))) __PYX_ERR(0, 3167, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_18MutableArcIterator_18set_value(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_arc)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_18set_value(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("set_value", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_18MutableArcIterator_set_value(__pyx_v_self, __pyx_v_arc, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.MutableArcIterator.set_value", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3178 + * self._aiter.get().SetValue(deref(arc._arc)) + * + * cpdef object value(self): # <<<<<<<<<<<<<< + * """ + * value(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_21value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_f_9pywrapfst_18MutableArcIterator_value(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("value", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_21value)) { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3178, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3178, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":3184 + * Returns the current arc. + * """ + * return _init_Arc(self._aiter.get().Value()) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); + __PYX_ERR(0, 3184, __pyx_L1_error) + } + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_Arc(__pyx_v_self->_aiter.get()->Value())); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":3178 + * self._aiter.get().SetValue(deref(arc._arc)) + * + * cpdef object value(self): # <<<<<<<<<<<<<< + * """ + * value(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pywrapfst.MutableArcIterator.value", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_21value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_18MutableArcIterator_20value[] = "\n value(self)\n\n Returns the current arc.\n "; +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_21value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("value (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_18MutableArcIterator_20value(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_20value(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("value", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pywrapfst_18MutableArcIterator_value(__pyx_v_self, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.MutableArcIterator.value", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._aiter,self._mfst cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_23__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_23__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_18MutableArcIterator_22__reduce_cython__(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_22__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._aiter,self._mfst cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._aiter,self._mfst cannot be converted to a Python object for pickling") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._aiter,self._mfst cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.MutableArcIterator.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._aiter,self._mfst cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._aiter,self._mfst cannot be converted to a Python object for pickling") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_25__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_25__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_18MutableArcIterator_24__setstate_cython__(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_24__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError("self._aiter,self._mfst cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._aiter,self._mfst cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__64, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._aiter,self._mfst cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._aiter,self._mfst cannot be converted to a Python object for pickling") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.MutableArcIterator.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3198 + * """ + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "".format(id(self)) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_13StateIterator_1__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_13StateIterator_1__repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_13StateIterator___repr__(((struct __pyx_obj_9pywrapfst_StateIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_13StateIterator___repr__(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "pywrapfst.pyx":3199 + * + * def __repr__(self): + * return "".format(id(self)) # <<<<<<<<<<<<<< + * + * def __init__(self, _Fst ifst): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_StateIterator_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self)); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3199, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3199, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3199, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":3198 + * """ + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "".format(id(self)) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pywrapfst.StateIterator.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3201 + * return "".format(id(self)) + * + * def __init__(self, _Fst ifst): # <<<<<<<<<<<<<< + * # Makes copy of the shared_ptr, potentially extending the FST's lifetime. + * self._fst = ifst._fst + */ + +/* Python wrapper */ +static int __pyx_pw_9pywrapfst_13StateIterator_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_9pywrapfst_13StateIterator_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 3201, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_ifst = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]); + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3201, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.StateIterator.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst), __pyx_ptype_9pywrapfst__Fst, 1, "ifst", 0))) __PYX_ERR(0, 3201, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_13StateIterator_2__init__(((struct __pyx_obj_9pywrapfst_StateIterator *)__pyx_v_self), __pyx_v_ifst); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pywrapfst_13StateIterator_2__init__(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst) { + int __pyx_r; + __Pyx_RefNannyDeclarations + std::shared_ptr __pyx_t_1; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "pywrapfst.pyx":3203 + * def __init__(self, _Fst ifst): + * # Makes copy of the shared_ptr, potentially extending the FST's lifetime. + * self._fst = ifst._fst # <<<<<<<<<<<<<< + * self._siter.reset(new fst.StateIteratorClass(deref(self._fst))) + * + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3203, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_ifst->_fst; + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3203, __pyx_L1_error) + } + __pyx_v_self->_fst = __pyx_t_1; + + /* "pywrapfst.pyx":3204 + * # Makes copy of the shared_ptr, potentially extending the FST's lifetime. + * self._fst = ifst._fst + * self._siter.reset(new fst.StateIteratorClass(deref(self._fst))) # <<<<<<<<<<<<<< + * + * # This just registers this class as a possible iterator. + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_siter"); + __PYX_ERR(0, 3204, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3204, __pyx_L1_error) + } + __pyx_v_self->_siter.reset(new fst::script::StateIteratorClass((*__pyx_v_self->_fst))); + + /* "pywrapfst.pyx":3201 + * return "".format(id(self)) + * + * def __init__(self, _Fst ifst): # <<<<<<<<<<<<<< + * # Makes copy of the shared_ptr, potentially extending the FST's lifetime. + * self._fst = ifst._fst + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst.StateIterator.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3207 + * + * # This just registers this class as a possible iterator. + * def __iter__(self): # <<<<<<<<<<<<<< + * return self + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_13StateIterator_5__iter__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_13StateIterator_5__iter__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_13StateIterator_4__iter__(((struct __pyx_obj_9pywrapfst_StateIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_13StateIterator_4__iter__(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__iter__", 0); + + /* "pywrapfst.pyx":3208 + * # This just registers this class as a possible iterator. + * def __iter__(self): + * return self # <<<<<<<<<<<<<< + * + * # Magic method used to get a Pythonic API out of the C++ API. + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "pywrapfst.pyx":3207 + * + * # This just registers this class as a possible iterator. + * def __iter__(self): # <<<<<<<<<<<<<< + * return self + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3211 + * + * # Magic method used to get a Pythonic API out of the C++ API. + * def __next__(self): # <<<<<<<<<<<<<< + * if self.done(): + * raise StopIteration + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_13StateIterator_7__next__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_13StateIterator_7__next__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__next__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_13StateIterator_6__next__(((struct __pyx_obj_9pywrapfst_StateIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_13StateIterator_6__next__(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self) { + __pyx_t_10basictypes_int64 __pyx_v_result; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__next__", 0); + + /* "pywrapfst.pyx":3212 + * # Magic method used to get a Pythonic API out of the C++ API. + * def __next__(self): + * if self.done(): # <<<<<<<<<<<<<< + * raise StopIteration + * cdef int64 result = self.value() + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "done"); + __PYX_ERR(0, 3212, __pyx_L1_error) + } + __pyx_t_1 = (((struct __pyx_vtabstruct_9pywrapfst_StateIterator *)__pyx_v_self->__pyx_vtab)->done(__pyx_v_self, 0) != 0); + if (__pyx_t_1) { + + /* "pywrapfst.pyx":3213 + * def __next__(self): + * if self.done(): + * raise StopIteration # <<<<<<<<<<<<<< + * cdef int64 result = self.value() + * self.next() + */ + __Pyx_Raise(__pyx_builtin_StopIteration, 0, 0, 0); + __PYX_ERR(0, 3213, __pyx_L1_error) + + /* "pywrapfst.pyx":3212 + * # Magic method used to get a Pythonic API out of the C++ API. + * def __next__(self): + * if self.done(): # <<<<<<<<<<<<<< + * raise StopIteration + * cdef int64 result = self.value() + */ + } + + /* "pywrapfst.pyx":3214 + * if self.done(): + * raise StopIteration + * cdef int64 result = self.value() # <<<<<<<<<<<<<< + * self.next() + * return result + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "value"); + __PYX_ERR(0, 3214, __pyx_L1_error) + } + __pyx_v_result = ((struct __pyx_vtabstruct_9pywrapfst_StateIterator *)__pyx_v_self->__pyx_vtab)->value(__pyx_v_self, 0); + + /* "pywrapfst.pyx":3215 + * raise StopIteration + * cdef int64 result = self.value() + * self.next() # <<<<<<<<<<<<<< + * return result + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "next"); + __PYX_ERR(0, 3215, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst_StateIterator *)__pyx_v_self->__pyx_vtab)->next(__pyx_v_self, 0); + + /* "pywrapfst.pyx":3216 + * cdef int64 result = self.value() + * self.next() + * return result # <<<<<<<<<<<<<< + * + * cpdef bool done(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyInt_From_int64_t(__pyx_v_result); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":3211 + * + * # Magic method used to get a Pythonic API out of the C++ API. + * def __next__(self): # <<<<<<<<<<<<<< + * if self.done(): + * raise StopIteration + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pywrapfst.StateIterator.__next__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3218 + * return result + * + * cpdef bool done(self): # <<<<<<<<<<<<<< + * """ + * done(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_13StateIterator_9done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static bool __pyx_f_9pywrapfst_13StateIterator_done(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self, int __pyx_skip_dispatch) { + bool __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + bool __pyx_t_5; + __Pyx_RefNannySetupContext("done", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_done); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_13StateIterator_9done)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3218, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3218, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3218, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":3227 + * True if the iterator is exhausted, False otherwise. + * """ + * return self._siter.get().Done() # <<<<<<<<<<<<<< + * + * cpdef void next(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_siter"); + __PYX_ERR(0, 3227, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_siter.get()->Done(); + goto __pyx_L0; + + /* "pywrapfst.pyx":3218 + * return result + * + * cpdef bool done(self): # <<<<<<<<<<<<<< + * """ + * done(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.StateIterator.done", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_13StateIterator_9done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_13StateIterator_8done[] = "\n done(self)\n\n Indicates whether the iterator is exhausted or not.\n\n Returns:\n True if the iterator is exhausted, False otherwise.\n "; +static PyObject *__pyx_pw_9pywrapfst_13StateIterator_9done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("done (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_13StateIterator_8done(((struct __pyx_obj_9pywrapfst_StateIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_13StateIterator_8done(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("done", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_9pywrapfst_13StateIterator_done(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.StateIterator.done", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3229 + * return self._siter.get().Done() + * + * cpdef void next(self): # <<<<<<<<<<<<<< + * """ + * next(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_13StateIterator_11next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static void __pyx_f_9pywrapfst_13StateIterator_next(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("next", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_next); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_13StateIterator_11next)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3229, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3229, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":3235 + * Advances the iterator. + * """ + * self._siter.get().Next() # <<<<<<<<<<<<<< + * + * cpdef void reset(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_siter"); + __PYX_ERR(0, 3235, __pyx_L1_error) + } + __pyx_v_self->_siter.get()->Next(); + + /* "pywrapfst.pyx":3229 + * return self._siter.get().Done() + * + * cpdef void next(self): # <<<<<<<<<<<<<< + * """ + * next(self) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.StateIterator.next", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_13StateIterator_11next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_13StateIterator_10next[] = "\n next(self)\n\n Advances the iterator.\n "; +static PyObject *__pyx_pw_9pywrapfst_13StateIterator_11next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("next (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_13StateIterator_10next(((struct __pyx_obj_9pywrapfst_StateIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_13StateIterator_10next(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("next", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_13StateIterator_next(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.StateIterator.next", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3237 + * self._siter.get().Next() + * + * cpdef void reset(self): # <<<<<<<<<<<<<< + * """ + * reset(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_13StateIterator_13reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static void __pyx_f_9pywrapfst_13StateIterator_reset(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("reset", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_reset); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_13StateIterator_13reset)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3237, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3237, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":3243 + * Resets the iterator to the initial position. + * """ + * self._siter.get().Reset() # <<<<<<<<<<<<<< + * + * cpdef int64 value(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_siter"); + __PYX_ERR(0, 3243, __pyx_L1_error) + } + __pyx_v_self->_siter.get()->Reset(); + + /* "pywrapfst.pyx":3237 + * self._siter.get().Next() + * + * cpdef void reset(self): # <<<<<<<<<<<<<< + * """ + * reset(self) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.StateIterator.reset", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_13StateIterator_13reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_13StateIterator_12reset[] = "\n reset(self)\n\n Resets the iterator to the initial position.\n "; +static PyObject *__pyx_pw_9pywrapfst_13StateIterator_13reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("reset (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_13StateIterator_12reset(((struct __pyx_obj_9pywrapfst_StateIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_13StateIterator_12reset(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("reset", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_13StateIterator_reset(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.StateIterator.reset", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3245 + * self._siter.get().Reset() + * + * cpdef int64 value(self): # <<<<<<<<<<<<<< + * """ + * value(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_13StateIterator_15value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_13StateIterator_value(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self, int __pyx_skip_dispatch) { + __pyx_t_10basictypes_int64 __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __pyx_t_10basictypes_int64 __pyx_t_5; + __Pyx_RefNannySetupContext("value", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3245, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_13StateIterator_15value)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3245, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3245, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3245, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":3251 + * Returns the current state index. + * """ + * return self._siter.get().Value() # <<<<<<<<<<<<<< + * + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_siter"); + __PYX_ERR(0, 3251, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_siter.get()->Value(); + goto __pyx_L0; + + /* "pywrapfst.pyx":3245 + * self._siter.get().Reset() + * + * cpdef int64 value(self): # <<<<<<<<<<<<<< + * """ + * value(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.StateIterator.value", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_13StateIterator_15value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_13StateIterator_14value[] = "\n value(self)\n\n Returns the current state index.\n "; +static PyObject *__pyx_pw_9pywrapfst_13StateIterator_15value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("value (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_13StateIterator_14value(((struct __pyx_obj_9pywrapfst_StateIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_13StateIterator_14value(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("value", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_f_9pywrapfst_13StateIterator_value(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3245, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.StateIterator.value", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._fst,self._siter cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_13StateIterator_17__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_13StateIterator_17__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_13StateIterator_16__reduce_cython__(((struct __pyx_obj_9pywrapfst_StateIterator *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_13StateIterator_16__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._fst,self._siter cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._fst,self._siter cannot be converted to a Python object for pickling") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__65, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._fst,self._siter cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.StateIterator.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._fst,self._siter cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._fst,self._siter cannot be converted to a Python object for pickling") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_13StateIterator_19__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_13StateIterator_19__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_13StateIterator_18__setstate_cython__(((struct __pyx_obj_9pywrapfst_StateIterator *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_13StateIterator_18__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError("self._fst,self._siter cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._fst,self._siter cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__66, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._fst,self._siter cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._fst,self._siter cannot be converted to a Python object for pickling") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.StateIterator.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3257 + * + * + * cdef _Fst _map(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * map_type=b"identity", + */ + +static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst__map(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, struct __pyx_opt_args_9pywrapfst__map *__pyx_optional_args) { + float __pyx_v_delta = __pyx_k__67; + PyObject *__pyx_v_map_type = ((PyObject *)__pyx_n_b_identity); + double __pyx_v_power = ((double)1.); + + /* "pywrapfst.pyx":3261 + * map_type=b"identity", + * double power=1., + * weight=None): # <<<<<<<<<<<<<< + * cdef fst.MapType map_type_enum + * if not fst.GetMapType(tostring(map_type), addr(map_type_enum)): + */ + PyObject *__pyx_v_weight = ((PyObject *)Py_None); + enum fst::script::MapType __pyx_v_map_type_enum; + fst::script::WeightClass __pyx_v_wc; + struct __pyx_obj_9pywrapfst__Fst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + std::string __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + fst::script::WeightClass __pyx_t_9; + fst::script::WeightClass __pyx_t_10; + __Pyx_RefNannySetupContext("_map", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_delta = __pyx_optional_args->delta; + if (__pyx_optional_args->__pyx_n > 1) { + __pyx_v_map_type = __pyx_optional_args->map_type; + if (__pyx_optional_args->__pyx_n > 2) { + __pyx_v_power = __pyx_optional_args->power; + if (__pyx_optional_args->__pyx_n > 3) { + __pyx_v_weight = __pyx_optional_args->weight; + } + } + } + } + } + + /* "pywrapfst.pyx":3263 + * weight=None): + * cdef fst.MapType map_type_enum + * if not fst.GetMapType(tostring(map_type), addr(map_type_enum)): # <<<<<<<<<<<<<< + * raise FstArgError("Unknown map type: {!r}".format(map_type)) + * cdef fst.WeightClass wc = (_get_WeightClass_or_One(ifst.weight_type(), + */ + __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_map_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3263, __pyx_L1_error) + __pyx_t_2 = ((!(fst::script::GetMapType(__pyx_t_1, (&__pyx_v_map_type_enum)) != 0)) != 0); + if (__pyx_t_2) { + + /* "pywrapfst.pyx":3264 + * cdef fst.MapType map_type_enum + * if not fst.GetMapType(tostring(map_type), addr(map_type_enum)): + * raise FstArgError("Unknown map type: {!r}".format(map_type)) # <<<<<<<<<<<<<< + * cdef fst.WeightClass wc = (_get_WeightClass_or_One(ifst.weight_type(), + * weight) if map_type_enum == fst.TIMES_MAPPER else + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Unknown_map_type_r, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + if (!__pyx_t_7) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_map_type); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_map_type}; + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3264, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_map_type}; + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3264, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_INCREF(__pyx_v_map_type); + __Pyx_GIVEREF(__pyx_v_map_type); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_map_type); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_6) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3264, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3264, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3264, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 3264, __pyx_L1_error) + + /* "pywrapfst.pyx":3263 + * weight=None): + * cdef fst.MapType map_type_enum + * if not fst.GetMapType(tostring(map_type), addr(map_type_enum)): # <<<<<<<<<<<<<< + * raise FstArgError("Unknown map type: {!r}".format(map_type)) + * cdef fst.WeightClass wc = (_get_WeightClass_or_One(ifst.weight_type(), + */ + } + + /* "pywrapfst.pyx":3266 + * raise FstArgError("Unknown map type: {!r}".format(map_type)) + * cdef fst.WeightClass wc = (_get_WeightClass_or_One(ifst.weight_type(), + * weight) if map_type_enum == fst.TIMES_MAPPER else # <<<<<<<<<<<<<< + * _get_WeightClass_or_Zero(ifst.weight_type(), weight)) + * return _init_XFst(fst.Map(deref(ifst._fst), map_type_enum, delta, power, wc)) + */ + if (((__pyx_v_map_type_enum == fst::script::TIMES_MAPPER) != 0)) { + + /* "pywrapfst.pyx":3265 + * if not fst.GetMapType(tostring(map_type), addr(map_type_enum)): + * raise FstArgError("Unknown map type: {!r}".format(map_type)) + * cdef fst.WeightClass wc = (_get_WeightClass_or_One(ifst.weight_type(), # <<<<<<<<<<<<<< + * weight) if map_type_enum == fst.TIMES_MAPPER else + * _get_WeightClass_or_Zero(ifst.weight_type(), weight)) + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "weight_type"); + __PYX_ERR(0, 3265, __pyx_L1_error) + } + + /* "pywrapfst.pyx":3266 + * raise FstArgError("Unknown map type: {!r}".format(map_type)) + * cdef fst.WeightClass wc = (_get_WeightClass_or_One(ifst.weight_type(), + * weight) if map_type_enum == fst.TIMES_MAPPER else # <<<<<<<<<<<<<< + * _get_WeightClass_or_Zero(ifst.weight_type(), weight)) + * return _init_XFst(fst.Map(deref(ifst._fst), map_type_enum, delta, power, wc)) + */ + __pyx_t_10 = __pyx_f_9pywrapfst__get_WeightClass_or_One(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->weight_type(__pyx_v_ifst, 0), __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3265, __pyx_L1_error) + __pyx_t_9 = __pyx_t_10; + } else { + + /* "pywrapfst.pyx":3267 + * cdef fst.WeightClass wc = (_get_WeightClass_or_One(ifst.weight_type(), + * weight) if map_type_enum == fst.TIMES_MAPPER else + * _get_WeightClass_or_Zero(ifst.weight_type(), weight)) # <<<<<<<<<<<<<< + * return _init_XFst(fst.Map(deref(ifst._fst), map_type_enum, delta, power, wc)) + * + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "weight_type"); + __PYX_ERR(0, 3267, __pyx_L1_error) + } + __pyx_t_10 = __pyx_f_9pywrapfst__get_WeightClass_or_Zero(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->weight_type(__pyx_v_ifst, 0), __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3267, __pyx_L1_error) + __pyx_t_9 = __pyx_t_10; + } + __pyx_v_wc = __pyx_t_9; + + /* "pywrapfst.pyx":3268 + * weight) if map_type_enum == fst.TIMES_MAPPER else + * _get_WeightClass_or_Zero(ifst.weight_type(), weight)) + * return _init_XFst(fst.Map(deref(ifst._fst), map_type_enum, delta, power, wc)) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3268, __pyx_L1_error) + } + __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_XFst(fst::script::Map((*__pyx_v_ifst->_fst), __pyx_v_map_type_enum, __pyx_v_delta, __pyx_v_power, __pyx_v_wc))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":3257 + * + * + * cdef _Fst _map(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * map_type=b"identity", + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pywrapfst._map", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3271 + * + * + * cpdef _Fst arcmap(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * map_type=b"identity", + */ + +static PyObject *__pyx_pw_9pywrapfst_17arcmap(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst_arcmap(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_arcmap *__pyx_optional_args) { + float __pyx_v_delta = __pyx_k__68; + PyObject *__pyx_v_map_type = ((PyObject *)__pyx_n_b_identity); + double __pyx_v_power = ((double)1.); + + /* "pywrapfst.pyx":3275 + * map_type=b"identity", + * double power=1., + * weight=None): # <<<<<<<<<<<<<< + * """ + * arcmap(ifst, delta=0.0009765625, map_type="identity", weight=None) + */ + PyObject *__pyx_v_weight = ((PyObject *)Py_None); + struct __pyx_obj_9pywrapfst__Fst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + struct __pyx_opt_args_9pywrapfst__map __pyx_t_2; + __Pyx_RefNannySetupContext("arcmap", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_delta = __pyx_optional_args->delta; + if (__pyx_optional_args->__pyx_n > 1) { + __pyx_v_map_type = __pyx_optional_args->map_type; + if (__pyx_optional_args->__pyx_n > 2) { + __pyx_v_power = __pyx_optional_args->power; + if (__pyx_optional_args->__pyx_n > 3) { + __pyx_v_weight = __pyx_optional_args->weight; + } + } + } + } + } + + /* "pywrapfst.pyx":3318 + * See also: `statemap`. + * """ + * return _map(ifst, delta, map_type, power, weight) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_2.__pyx_n = 4; + __pyx_t_2.delta = __pyx_v_delta; + __pyx_t_2.map_type = __pyx_v_map_type; + __pyx_t_2.power = __pyx_v_power; + __pyx_t_2.weight = __pyx_v_weight; + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__map(__pyx_v_ifst, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":3271 + * + * + * cpdef _Fst arcmap(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * map_type=b"identity", + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.arcmap", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_17arcmap(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_16arcmap[] = "\n arcmap(ifst, delta=0.0009765625, map_type=\"identity\", weight=None)\n\n Constructively applies a transform to all arcs and final states.\n\n This operation transforms each arc and final state in the input FST using\n one of the following:\n\n * identity: maps to self.\n * input_epsilon: replaces all input labels with epsilon.\n * invert: reciprocates all non-Zero weights.\n * float_power: raises all weights to a floating-point power.\n * output_epsilon: replaces all output labels with epsilon.\n * quantize: quantizes weights.\n * plus: adds a constant to all weights.\n * power: raises all weights to an integral power.\n * rmweight: replaces all non-Zero weights with 1.\n * superfinal: redirects final states to a new superfinal state.\n * times: right-multiplies a constant to all weights.\n * to_log: converts weights to the log semiring.\n * to_log64: converts weights to the log64 semiring.\n * to_standard: converts weights to the tropical (\"standard\") semiring.\n\n Args:\n ifst: The input FST.\n delta: Comparison/quantization delta (ignored unless `map_type` is\n `quantize`).\n map_type: A string matching a known mapping operation (see above).\n power: A positive scalar or integer power; ignored unless `map_type` is\n `float_power` or `power` (in which case it defaults to 1).\n weight: A Weight or weight string passed to the arc-mapper; ignored unless\n `map_type` is `plus` (in which case it defaults to semiring Zero) or\n `times` (in which case it defaults to semiring One).\n\n Returns:\n An FST with arcs and final states remapped.\n\n Raises:\n FstArgError: Unknown map type.\n\n See also: `statemap`.\n "; +static PyObject *__pyx_pw_9pywrapfst_17arcmap(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0; + float __pyx_v_delta; + PyObject *__pyx_v_map_type = 0; + double __pyx_v_power; + PyObject *__pyx_v_weight = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("arcmap (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_delta,&__pyx_n_s_map_type,&__pyx_n_s_power,&__pyx_n_s_weight,0}; + PyObject* values[5] = {0,0,0,0,0}; + values[2] = ((PyObject *)__pyx_n_b_identity); + + /* "pywrapfst.pyx":3275 + * map_type=b"identity", + * double power=1., + * weight=None): # <<<<<<<<<<<<<< + * """ + * arcmap(ifst, delta=0.0009765625, map_type="identity", weight=None) + */ + values[4] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta); + if (value) { values[1] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_map_type); + if (value) { values[2] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_power); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weight); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "arcmap") < 0)) __PYX_ERR(0, 3271, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ifst = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]); + if (values[1]) { + __pyx_v_delta = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_delta == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3272, __pyx_L3_error) + } else { + __pyx_v_delta = __pyx_k__68; + } + __pyx_v_map_type = values[2]; + if (values[3]) { + __pyx_v_power = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_power == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3274, __pyx_L3_error) + } else { + __pyx_v_power = ((double)1.); + } + __pyx_v_weight = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("arcmap", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3271, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.arcmap", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst), __pyx_ptype_9pywrapfst__Fst, 1, "ifst", 0))) __PYX_ERR(0, 3271, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_16arcmap(__pyx_self, __pyx_v_ifst, __pyx_v_delta, __pyx_v_map_type, __pyx_v_power, __pyx_v_weight); + + /* "pywrapfst.pyx":3271 + * + * + * cpdef _Fst arcmap(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * map_type=b"identity", + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_16arcmap(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, PyObject *__pyx_v_map_type, double __pyx_v_power, PyObject *__pyx_v_weight) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + struct __pyx_opt_args_9pywrapfst_arcmap __pyx_t_2; + __Pyx_RefNannySetupContext("arcmap", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 4; + __pyx_t_2.delta = __pyx_v_delta; + __pyx_t_2.map_type = __pyx_v_map_type; + __pyx_t_2.power = __pyx_v_power; + __pyx_t_2.weight = __pyx_v_weight; + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_arcmap(__pyx_v_ifst, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.arcmap", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3321 + * + * + * cpdef _MutableFst compose(_Fst ifst1, # <<<<<<<<<<<<<< + * _Fst ifst2, + * compose_filter=b"auto", + */ + +static PyObject *__pyx_pw_9pywrapfst_19compose(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_compose(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_compose *__pyx_optional_args) { + PyObject *__pyx_v_compose_filter = ((PyObject *)__pyx_n_b_auto); + + /* "pywrapfst.pyx":3324 + * _Fst ifst2, + * compose_filter=b"auto", + * bool connect=True): # <<<<<<<<<<<<<< + * """ + * compose(ifst1, ifst2, compose_filter="auto", connect=True) + */ + bool __pyx_v_connect = ((bool)1); + std::unique_ptr __pyx_v_tfst; + std::unique_ptr __pyx_v_opts; + struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + std::string __pyx_t_1; + enum fst::ComposeFilter __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("compose", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_compose_filter = __pyx_optional_args->compose_filter; + if (__pyx_optional_args->__pyx_n > 1) { + __pyx_v_connect = __pyx_optional_args->connect; + } + } + } + + /* "pywrapfst.pyx":3349 + * """ + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst1.arc_type())) # <<<<<<<<<<<<<< + * cdef unique_ptr[fst.ComposeOptions] opts + * opts.reset(new fst.ComposeOptions(connect, + */ + if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "arc_type"); + __PYX_ERR(0, 3349, __pyx_L1_error) + } + __pyx_v_tfst.reset(new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst1->__pyx_vtab)->arc_type(__pyx_v_ifst1, 0))); + + /* "pywrapfst.pyx":3352 + * cdef unique_ptr[fst.ComposeOptions] opts + * opts.reset(new fst.ComposeOptions(connect, + * _get_compose_filter(tostring(compose_filter)))) # <<<<<<<<<<<<<< + * fst.Compose(deref(ifst1._fst), deref(ifst2._fst), tfst.get(), deref(opts)) + * return _init_MutableFst(tfst.release()) + */ + __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_compose_filter, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3352, __pyx_L1_error) + __pyx_t_2 = __pyx_f_9pywrapfst__get_compose_filter(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3352, __pyx_L1_error) + + /* "pywrapfst.pyx":3351 + * tfst.reset(new fst.VectorFstClass(ifst1.arc_type())) + * cdef unique_ptr[fst.ComposeOptions] opts + * opts.reset(new fst.ComposeOptions(connect, # <<<<<<<<<<<<<< + * _get_compose_filter(tostring(compose_filter)))) + * fst.Compose(deref(ifst1._fst), deref(ifst2._fst), tfst.get(), deref(opts)) + */ + __pyx_v_opts.reset(new fst::ComposeOptions(__pyx_v_connect, __pyx_t_2)); + + /* "pywrapfst.pyx":3353 + * opts.reset(new fst.ComposeOptions(connect, + * _get_compose_filter(tostring(compose_filter)))) + * fst.Compose(deref(ifst1._fst), deref(ifst2._fst), tfst.get(), deref(opts)) # <<<<<<<<<<<<<< + * return _init_MutableFst(tfst.release()) + * + */ + if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3353, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_ifst2) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3353, __pyx_L1_error) + } + fst::script::Compose((*__pyx_v_ifst1->_fst), (*__pyx_v_ifst2->_fst), __pyx_v_tfst.get(), (*__pyx_v_opts)); + + /* "pywrapfst.pyx":3354 + * _get_compose_filter(tostring(compose_filter)))) + * fst.Compose(deref(ifst1._fst), deref(ifst2._fst), tfst.get(), deref(opts)) + * return _init_MutableFst(tfst.release()) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst.release())); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3354, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = ((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":3321 + * + * + * cpdef _MutableFst compose(_Fst ifst1, # <<<<<<<<<<<<<< + * _Fst ifst2, + * compose_filter=b"auto", + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pywrapfst.compose", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_19compose(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_18compose[] = "\n compose(ifst1, ifst2, compose_filter=\"auto\", connect=True)\n\n Constructively composes two FSTs.\n\n This operation computes the composition of two FSTs. If A transduces string\n x to y with weight a and B transduces y to z with weight b, then their\n composition transduces string x to z with weight a \\otimes b. The output\n labels of the first transducer or the input labels of the second transducer\n must be sorted (or otherwise support appropriate matchers).\n\n Args:\n ifst1: The first input FST.\n ifst2: The second input FST.\n compose_filter: A string matching a known composition filter; one of:\n \"alt_sequence\", \"auto\", \"match\", \"null\", \"sequence\", \"trivial\".\n connect: Should output be trimmed?\n\n Returns:\n An FST.\n\n See also: `arcsort`.\n "; +static PyObject *__pyx_pw_9pywrapfst_19compose(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1 = 0; + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2 = 0; + PyObject *__pyx_v_compose_filter = 0; + bool __pyx_v_connect; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("compose (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst1,&__pyx_n_s_ifst2,&__pyx_n_s_compose_filter,&__pyx_n_s_connect,0}; + PyObject* values[4] = {0,0,0,0}; + values[2] = ((PyObject *)__pyx_n_b_auto); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst1)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst2)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("compose", 0, 2, 4, 1); __PYX_ERR(0, 3321, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_compose_filter); + if (value) { values[2] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_connect); + if (value) { values[3] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "compose") < 0)) __PYX_ERR(0, 3321, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ifst1 = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]); + __pyx_v_ifst2 = ((struct __pyx_obj_9pywrapfst__Fst *)values[1]); + __pyx_v_compose_filter = values[2]; + if (values[3]) { + __pyx_v_connect = __Pyx_PyObject_IsTrue(values[3]); if (unlikely((__pyx_v_connect == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3324, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":3324 + * _Fst ifst2, + * compose_filter=b"auto", + * bool connect=True): # <<<<<<<<<<<<<< + * """ + * compose(ifst1, ifst2, compose_filter="auto", connect=True) + */ + __pyx_v_connect = ((bool)1); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("compose", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3321, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.compose", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst1), __pyx_ptype_9pywrapfst__Fst, 1, "ifst1", 0))) __PYX_ERR(0, 3321, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst2), __pyx_ptype_9pywrapfst__Fst, 1, "ifst2", 0))) __PYX_ERR(0, 3322, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_18compose(__pyx_self, __pyx_v_ifst1, __pyx_v_ifst2, __pyx_v_compose_filter, __pyx_v_connect); + + /* "pywrapfst.pyx":3321 + * + * + * cpdef _MutableFst compose(_Fst ifst1, # <<<<<<<<<<<<<< + * _Fst ifst2, + * compose_filter=b"auto", + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_18compose(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, PyObject *__pyx_v_compose_filter, bool __pyx_v_connect) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + struct __pyx_opt_args_9pywrapfst_compose __pyx_t_2; + __Pyx_RefNannySetupContext("compose", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 2; + __pyx_t_2.compose_filter = __pyx_v_compose_filter; + __pyx_t_2.connect = __pyx_v_connect; + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_compose(__pyx_v_ifst1, __pyx_v_ifst2, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3321, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.compose", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3357 + * + * + * cpdef _Fst convert(_Fst ifst, fst_type=None): # <<<<<<<<<<<<<< + * """ + * convert(ifst, fst_type=None) + */ + +static PyObject *__pyx_pw_9pywrapfst_21convert(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst_convert(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_convert *__pyx_optional_args) { + PyObject *__pyx_v_fst_type = ((PyObject *)Py_None); + std::string __pyx_v_fst_type_string; + std::unique_ptr __pyx_v_tfst; + struct __pyx_obj_9pywrapfst__Fst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + std::string __pyx_t_1; + int __pyx_t_2; + std::string __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + __Pyx_RefNannySetupContext("convert", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_fst_type = __pyx_optional_args->fst_type; + } + } + + /* "pywrapfst.pyx":3374 + * FstOpError: Conversion failed. + * """ + * cdef string fst_type_string = b"" if fst_type is None else tostring(fst_type) # <<<<<<<<<<<<<< + * cdef unique_ptr[fst.FstClass] tfst + * tfst.reset(fst.Convert(deref(ifst._fst), fst_type_string)) + */ + __pyx_t_2 = (__pyx_v_fst_type == Py_None); + if ((__pyx_t_2 != 0)) { + __pyx_t_3 = __pyx_convert_string_from_py_std__in_string(__pyx_kp_b__24); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3374, __pyx_L1_error) + __pyx_t_1 = __pyx_t_3; + } else { + __pyx_t_3 = __pyx_f_9pywrapfst_tostring(__pyx_v_fst_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3374, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3374, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __pyx_convert_string_from_py_std__in_string(__pyx_t_4); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3374, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_1 = __pyx_t_3; + } + __pyx_v_fst_type_string = __pyx_t_1; + + /* "pywrapfst.pyx":3376 + * cdef string fst_type_string = b"" if fst_type is None else tostring(fst_type) + * cdef unique_ptr[fst.FstClass] tfst + * tfst.reset(fst.Convert(deref(ifst._fst), fst_type_string)) # <<<<<<<<<<<<<< + * # Script-land Convert returns a null pointer to signal failure. + * if tfst.get() == NULL: + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3376, __pyx_L1_error) + } + __pyx_v_tfst.reset(fst::script::Convert((*__pyx_v_ifst->_fst), __pyx_v_fst_type_string)); + + /* "pywrapfst.pyx":3378 + * tfst.reset(fst.Convert(deref(ifst._fst), fst_type_string)) + * # Script-land Convert returns a null pointer to signal failure. + * if tfst.get() == NULL: # <<<<<<<<<<<<<< + * raise FstOpError("Conversion to {!r} failed".format(fst_type)) + * return _init_XFst(tfst.release()) + */ + __pyx_t_2 = ((__pyx_v_tfst.get() == NULL) != 0); + if (__pyx_t_2) { + + /* "pywrapfst.pyx":3379 + * # Script-land Convert returns a null pointer to signal failure. + * if tfst.get() == NULL: + * raise FstOpError("Conversion to {!r} failed".format(fst_type)) # <<<<<<<<<<<<<< + * return _init_XFst(tfst.release()) + * + */ + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Conversion_to_r_failed, __pyx_n_s_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + if (!__pyx_t_8) { + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_fst_type); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_fst_type}; + __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3379, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_6); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_fst_type}; + __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3379, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_6); + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL; + __Pyx_INCREF(__pyx_v_fst_type); + __Pyx_GIVEREF(__pyx_v_fst_type); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_v_fst_type); + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_7) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3379, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3379, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3379, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 3379, __pyx_L1_error) + + /* "pywrapfst.pyx":3378 + * tfst.reset(fst.Convert(deref(ifst._fst), fst_type_string)) + * # Script-land Convert returns a null pointer to signal failure. + * if tfst.get() == NULL: # <<<<<<<<<<<<<< + * raise FstOpError("Conversion to {!r} failed".format(fst_type)) + * return _init_XFst(tfst.release()) + */ + } + + /* "pywrapfst.pyx":3380 + * if tfst.get() == NULL: + * raise FstOpError("Conversion to {!r} failed".format(fst_type)) + * return _init_XFst(tfst.release()) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_4 = ((PyObject *)__pyx_f_9pywrapfst__init_XFst(__pyx_v_tfst.release())); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_4); + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":3357 + * + * + * cpdef _Fst convert(_Fst ifst, fst_type=None): # <<<<<<<<<<<<<< + * """ + * convert(ifst, fst_type=None) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("pywrapfst.convert", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_21convert(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_20convert[] = "\n convert(ifst, fst_type=None)\n\n Constructively converts an FST to a new internal representation.\n\n Args:\n ifst: The input FST.\n fst_type: A string indicating the FST type to convert to, or None if\n no conversion is desired.\n\n Returns:\n An equivalent Fst converted to the desired FST type.\n\n Raises:\n FstOpError: Conversion failed.\n "; +static PyObject *__pyx_pw_9pywrapfst_21convert(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0; + PyObject *__pyx_v_fst_type = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("convert (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_fst_type,0}; + PyObject* values[2] = {0,0}; + values[1] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_fst_type); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "convert") < 0)) __PYX_ERR(0, 3357, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ifst = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]); + __pyx_v_fst_type = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("convert", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3357, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.convert", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst), __pyx_ptype_9pywrapfst__Fst, 1, "ifst", 0))) __PYX_ERR(0, 3357, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_20convert(__pyx_self, __pyx_v_ifst, __pyx_v_fst_type); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_20convert(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, PyObject *__pyx_v_fst_type) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + struct __pyx_opt_args_9pywrapfst_convert __pyx_t_2; + __Pyx_RefNannySetupContext("convert", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 1; + __pyx_t_2.fst_type = __pyx_v_fst_type; + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_convert(__pyx_v_ifst, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.convert", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3383 + * + * + * cpdef _MutableFst determinize(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kShortestDelta, + * det_type=b"functional", + */ + +static PyObject *__pyx_pw_9pywrapfst_23determinize(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_determinize(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_determinize *__pyx_optional_args) { + float __pyx_v_delta = __pyx_k__69; + PyObject *__pyx_v_det_type = ((PyObject *)__pyx_n_b_functional); + __pyx_t_10basictypes_int64 __pyx_v_nstate = __pyx_k__70; + __pyx_t_10basictypes_int64 __pyx_v_subsequential_label = ((__pyx_t_10basictypes_int64)0); + + /* "pywrapfst.pyx":3388 + * int64 nstate=fst.kNoStateId, + * int64 subsequential_label=0, + * weight=None, # <<<<<<<<<<<<<< + * bool increment_subsequential_label=False): + * """ + */ + PyObject *__pyx_v_weight = ((PyObject *)Py_None); + + /* "pywrapfst.pyx":3389 + * int64 subsequential_label=0, + * weight=None, + * bool increment_subsequential_label=False): # <<<<<<<<<<<<<< + * """ + * determinize(ifst, delta=1e-6, det_type="functional", + */ + bool __pyx_v_increment_subsequential_label = ((bool)0); + std::unique_ptr __pyx_v_tfst; + fst::script::WeightClass __pyx_v_wc; + enum fst::DeterminizeType __pyx_v_determinize_type_enum; + std::unique_ptr __pyx_v_opts; + struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + fst::script::WeightClass __pyx_t_1; + std::string __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + __Pyx_RefNannySetupContext("determinize", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_delta = __pyx_optional_args->delta; + if (__pyx_optional_args->__pyx_n > 1) { + __pyx_v_det_type = __pyx_optional_args->det_type; + if (__pyx_optional_args->__pyx_n > 2) { + __pyx_v_nstate = __pyx_optional_args->nstate; + if (__pyx_optional_args->__pyx_n > 3) { + __pyx_v_subsequential_label = __pyx_optional_args->subsequential_label; + if (__pyx_optional_args->__pyx_n > 4) { + __pyx_v_weight = __pyx_optional_args->weight; + if (__pyx_optional_args->__pyx_n > 5) { + __pyx_v_increment_subsequential_label = __pyx_optional_args->increment_subsequential_label; + } + } + } + } + } + } + } + + /* "pywrapfst.pyx":3425 + * """ + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) # <<<<<<<<<<<<<< + * # Threshold is set to semiring Zero (no pruning) if weight unspecified. + * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "arc_type"); + __PYX_ERR(0, 3425, __pyx_L1_error) + } + __pyx_v_tfst.reset(new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->arc_type(__pyx_v_ifst, 0))); + + /* "pywrapfst.pyx":3427 + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + * # Threshold is set to semiring Zero (no pruning) if weight unspecified. + * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), # <<<<<<<<<<<<<< + * weight) + * cdef fst.DeterminizeType determinize_type_enum + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "weight_type"); + __PYX_ERR(0, 3427, __pyx_L1_error) + } + + /* "pywrapfst.pyx":3428 + * # Threshold is set to semiring Zero (no pruning) if weight unspecified. + * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), + * weight) # <<<<<<<<<<<<<< + * cdef fst.DeterminizeType determinize_type_enum + * if not fst.GetDeterminizeType(tostring(det_type), + */ + __pyx_t_1 = __pyx_f_9pywrapfst__get_WeightClass_or_Zero(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->weight_type(__pyx_v_ifst, 0), __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3427, __pyx_L1_error) + __pyx_v_wc = __pyx_t_1; + + /* "pywrapfst.pyx":3430 + * weight) + * cdef fst.DeterminizeType determinize_type_enum + * if not fst.GetDeterminizeType(tostring(det_type), # <<<<<<<<<<<<<< + * addr(determinize_type_enum)): + * raise FstArgError("Unknown determinization type: {!r}".format(det_type)) + */ + __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_v_det_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3430, __pyx_L1_error) + + /* "pywrapfst.pyx":3431 + * cdef fst.DeterminizeType determinize_type_enum + * if not fst.GetDeterminizeType(tostring(det_type), + * addr(determinize_type_enum)): # <<<<<<<<<<<<<< + * raise FstArgError("Unknown determinization type: {!r}".format(det_type)) + * cdef unique_ptr[fst.DeterminizeOptions] opts + */ + __pyx_t_3 = ((!(fst::script::GetDeterminizeType(__pyx_t_2, (&__pyx_v_determinize_type_enum)) != 0)) != 0); + + /* "pywrapfst.pyx":3430 + * weight) + * cdef fst.DeterminizeType determinize_type_enum + * if not fst.GetDeterminizeType(tostring(det_type), # <<<<<<<<<<<<<< + * addr(determinize_type_enum)): + * raise FstArgError("Unknown determinization type: {!r}".format(det_type)) + */ + if (__pyx_t_3) { + + /* "pywrapfst.pyx":3432 + * if not fst.GetDeterminizeType(tostring(det_type), + * addr(determinize_type_enum)): + * raise FstArgError("Unknown determinization type: {!r}".format(det_type)) # <<<<<<<<<<<<<< + * cdef unique_ptr[fst.DeterminizeOptions] opts + * opts.reset(new fst.DeterminizeOptions(delta, wc, nstate, subsequential_label, + */ + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Unknown_determinization_type_r, __pyx_n_s_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + if (!__pyx_t_8) { + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_det_type); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_det_type}; + __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3432, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_6); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_det_type}; + __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3432, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_6); + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL; + __Pyx_INCREF(__pyx_v_det_type); + __Pyx_GIVEREF(__pyx_v_det_type); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_v_det_type); + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_7) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3432, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3432, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3432, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 3432, __pyx_L1_error) + + /* "pywrapfst.pyx":3430 + * weight) + * cdef fst.DeterminizeType determinize_type_enum + * if not fst.GetDeterminizeType(tostring(det_type), # <<<<<<<<<<<<<< + * addr(determinize_type_enum)): + * raise FstArgError("Unknown determinization type: {!r}".format(det_type)) + */ + } + + /* "pywrapfst.pyx":3434 + * raise FstArgError("Unknown determinization type: {!r}".format(det_type)) + * cdef unique_ptr[fst.DeterminizeOptions] opts + * opts.reset(new fst.DeterminizeOptions(delta, wc, nstate, subsequential_label, # <<<<<<<<<<<<<< + * determinize_type_enum, + * increment_subsequential_label)) + */ + __pyx_v_opts.reset(new fst::script::DeterminizeOptions(__pyx_v_delta, __pyx_v_wc, __pyx_v_nstate, __pyx_v_subsequential_label, __pyx_v_determinize_type_enum, __pyx_v_increment_subsequential_label)); + + /* "pywrapfst.pyx":3437 + * determinize_type_enum, + * increment_subsequential_label)) + * fst.Determinize(deref(ifst._fst), tfst.get(), deref(opts)) # <<<<<<<<<<<<<< + * return _init_MutableFst(tfst.release()) + * + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3437, __pyx_L1_error) + } + fst::script::Determinize((*__pyx_v_ifst->_fst), __pyx_v_tfst.get(), (*__pyx_v_opts)); + + /* "pywrapfst.pyx":3438 + * increment_subsequential_label)) + * fst.Determinize(deref(ifst._fst), tfst.get(), deref(opts)) + * return _init_MutableFst(tfst.release()) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_4 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst.release())); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3438, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = ((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_t_4); + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":3383 + * + * + * cpdef _MutableFst determinize(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kShortestDelta, + * det_type=b"functional", + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("pywrapfst.determinize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_23determinize(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_22determinize[] = "\n determinize(ifst, delta=1e-6, det_type=\"functional\",\n nstate=NO_STATE_ID, subsequential_label=0, weight=None,\n incremental_subsequential_label=False)\n\n Constructively determinizes a weighted FST.\n\n This operations creates an equivalent FST that has the property that no\n state has two transitions with the same input label. For this algorithm,\n epsilon transitions are treated as regular symbols (cf. `rmepsilon`).\n\n Args:\n ifst: The input FST.\n delta: Comparison/quantization delta.\n det_type: Type of determinization; one of: \"functional\" (input transducer is\n functional), \"nonfunctional\" (input transducer is not functional) and\n disambiguate\" (input transducer is not functional but only keep the min\n of ambiguous outputs).\n nstate: State number threshold.\n subsequential_label: Input label of arc corresponding to residual final\n output when producing a subsequential transducer.\n weight: A Weight or weight string indicating the desired weight threshold\n below which paths are pruned; if omitted, no paths are pruned.\n increment_subsequential_label: Increment subsequential when creating\n several arcs for the residual final output at a given state.\n\n Returns:\n An equivalent deterministic FST.\n\n Raises:\n FstArgError: Unknown determinization type.\n\n See also: `disambiguate`, `rmepsilon`.\n "; +static PyObject *__pyx_pw_9pywrapfst_23determinize(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0; + float __pyx_v_delta; + PyObject *__pyx_v_det_type = 0; + __pyx_t_10basictypes_int64 __pyx_v_nstate; + __pyx_t_10basictypes_int64 __pyx_v_subsequential_label; + PyObject *__pyx_v_weight = 0; + bool __pyx_v_increment_subsequential_label; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("determinize (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_delta,&__pyx_n_s_det_type,&__pyx_n_s_nstate,&__pyx_n_s_subsequential_label,&__pyx_n_s_weight,&__pyx_n_s_increment_subsequential_label,0}; + PyObject* values[7] = {0,0,0,0,0,0,0}; + values[2] = ((PyObject *)__pyx_n_b_functional); + + /* "pywrapfst.pyx":3388 + * int64 nstate=fst.kNoStateId, + * int64 subsequential_label=0, + * weight=None, # <<<<<<<<<<<<<< + * bool increment_subsequential_label=False): + * """ + */ + values[5] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta); + if (value) { values[1] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_det_type); + if (value) { values[2] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nstate); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_subsequential_label); + if (value) { values[4] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weight); + if (value) { values[5] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_increment_subsequential_label); + if (value) { values[6] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "determinize") < 0)) __PYX_ERR(0, 3383, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ifst = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]); + if (values[1]) { + __pyx_v_delta = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_delta == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3384, __pyx_L3_error) + } else { + __pyx_v_delta = __pyx_k__69; + } + __pyx_v_det_type = values[2]; + if (values[3]) { + __pyx_v_nstate = __Pyx_PyInt_As_int64_t(values[3]); if (unlikely((__pyx_v_nstate == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3386, __pyx_L3_error) + } else { + __pyx_v_nstate = __pyx_k__70; + } + if (values[4]) { + __pyx_v_subsequential_label = __Pyx_PyInt_As_int64_t(values[4]); if (unlikely((__pyx_v_subsequential_label == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3387, __pyx_L3_error) + } else { + __pyx_v_subsequential_label = ((__pyx_t_10basictypes_int64)0); + } + __pyx_v_weight = values[5]; + if (values[6]) { + __pyx_v_increment_subsequential_label = __Pyx_PyObject_IsTrue(values[6]); if (unlikely((__pyx_v_increment_subsequential_label == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3389, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":3389 + * int64 subsequential_label=0, + * weight=None, + * bool increment_subsequential_label=False): # <<<<<<<<<<<<<< + * """ + * determinize(ifst, delta=1e-6, det_type="functional", + */ + __pyx_v_increment_subsequential_label = ((bool)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("determinize", 0, 1, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3383, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.determinize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst), __pyx_ptype_9pywrapfst__Fst, 1, "ifst", 0))) __PYX_ERR(0, 3383, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_22determinize(__pyx_self, __pyx_v_ifst, __pyx_v_delta, __pyx_v_det_type, __pyx_v_nstate, __pyx_v_subsequential_label, __pyx_v_weight, __pyx_v_increment_subsequential_label); + + /* "pywrapfst.pyx":3383 + * + * + * cpdef _MutableFst determinize(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kShortestDelta, + * det_type=b"functional", + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_22determinize(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, PyObject *__pyx_v_det_type, __pyx_t_10basictypes_int64 __pyx_v_nstate, __pyx_t_10basictypes_int64 __pyx_v_subsequential_label, PyObject *__pyx_v_weight, bool __pyx_v_increment_subsequential_label) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + struct __pyx_opt_args_9pywrapfst_determinize __pyx_t_2; + __Pyx_RefNannySetupContext("determinize", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 6; + __pyx_t_2.delta = __pyx_v_delta; + __pyx_t_2.det_type = __pyx_v_det_type; + __pyx_t_2.nstate = __pyx_v_nstate; + __pyx_t_2.subsequential_label = __pyx_v_subsequential_label; + __pyx_t_2.weight = __pyx_v_weight; + __pyx_t_2.increment_subsequential_label = __pyx_v_increment_subsequential_label; + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_determinize(__pyx_v_ifst, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.determinize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3441 + * + * + * cpdef _MutableFst difference(_Fst ifst1, # <<<<<<<<<<<<<< + * _Fst ifst2, + * compose_filter=b"auto", + */ + +static PyObject *__pyx_pw_9pywrapfst_25difference(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_difference(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_difference *__pyx_optional_args) { + PyObject *__pyx_v_compose_filter = ((PyObject *)__pyx_n_b_auto); + + /* "pywrapfst.pyx":3444 + * _Fst ifst2, + * compose_filter=b"auto", + * bool connect=True): # <<<<<<<<<<<<<< + * """ + * difference(ifst1, ifst2, compose_filter="auto", connect=True) + */ + bool __pyx_v_connect = ((bool)1); + std::unique_ptr __pyx_v_tfst; + std::unique_ptr __pyx_v_opts; + struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + std::string __pyx_t_1; + enum fst::ComposeFilter __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("difference", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_compose_filter = __pyx_optional_args->compose_filter; + if (__pyx_optional_args->__pyx_n > 1) { + __pyx_v_connect = __pyx_optional_args->connect; + } + } + } + + /* "pywrapfst.pyx":3468 + * """ + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst1.arc_type())) # <<<<<<<<<<<<<< + * cdef unique_ptr[fst.ComposeOptions] opts + * opts.reset(new fst.ComposeOptions(connect, _get_compose_filter( + */ + if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "arc_type"); + __PYX_ERR(0, 3468, __pyx_L1_error) + } + __pyx_v_tfst.reset(new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst1->__pyx_vtab)->arc_type(__pyx_v_ifst1, 0))); + + /* "pywrapfst.pyx":3471 + * cdef unique_ptr[fst.ComposeOptions] opts + * opts.reset(new fst.ComposeOptions(connect, _get_compose_filter( + * tostring(compose_filter)))) # <<<<<<<<<<<<<< + * fst.Difference(deref(ifst1._fst), deref(ifst2._fst), tfst.get(), deref(opts)) + * return _init_MutableFst(tfst.release()) + */ + __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_compose_filter, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3471, __pyx_L1_error) + + /* "pywrapfst.pyx":3470 + * tfst.reset(new fst.VectorFstClass(ifst1.arc_type())) + * cdef unique_ptr[fst.ComposeOptions] opts + * opts.reset(new fst.ComposeOptions(connect, _get_compose_filter( # <<<<<<<<<<<<<< + * tostring(compose_filter)))) + * fst.Difference(deref(ifst1._fst), deref(ifst2._fst), tfst.get(), deref(opts)) + */ + __pyx_t_2 = __pyx_f_9pywrapfst__get_compose_filter(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3470, __pyx_L1_error) + __pyx_v_opts.reset(new fst::ComposeOptions(__pyx_v_connect, __pyx_t_2)); + + /* "pywrapfst.pyx":3472 + * opts.reset(new fst.ComposeOptions(connect, _get_compose_filter( + * tostring(compose_filter)))) + * fst.Difference(deref(ifst1._fst), deref(ifst2._fst), tfst.get(), deref(opts)) # <<<<<<<<<<<<<< + * return _init_MutableFst(tfst.release()) + * + */ + if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3472, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_ifst2) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3472, __pyx_L1_error) + } + fst::script::Difference((*__pyx_v_ifst1->_fst), (*__pyx_v_ifst2->_fst), __pyx_v_tfst.get(), (*__pyx_v_opts)); + + /* "pywrapfst.pyx":3473 + * tostring(compose_filter)))) + * fst.Difference(deref(ifst1._fst), deref(ifst2._fst), tfst.get(), deref(opts)) + * return _init_MutableFst(tfst.release()) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst.release())); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3473, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = ((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":3441 + * + * + * cpdef _MutableFst difference(_Fst ifst1, # <<<<<<<<<<<<<< + * _Fst ifst2, + * compose_filter=b"auto", + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pywrapfst.difference", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_25difference(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_24difference[] = "\n difference(ifst1, ifst2, compose_filter=\"auto\", connect=True)\n\n Constructively computes the difference of two FSTs.\n\n This operation computes the difference between two FSAs. Only strings that are\n in the first automaton but not in second are retained in the result. The first\n argument must be an acceptor; the second argument must be an unweighted,\n epsilon-free, deterministic acceptor. The output labels of the first\n transducer or the input labels of the second transducer must be sorted (or\n otherwise support appropriate matchers).\n\n Args:\n ifst1: The first input FST.\n ifst2: The second input FST.\n compose_filter: A string matching a known composition filter; one of:\n \"alt_sequence\", \"auto\", \"match\", \"null\", \"sequence\", \"trivial\".\n connect: Should the output FST be trimmed?\n\n Returns:\n An FST representing the difference of the FSTs.\n "; +static PyObject *__pyx_pw_9pywrapfst_25difference(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1 = 0; + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2 = 0; + PyObject *__pyx_v_compose_filter = 0; + bool __pyx_v_connect; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("difference (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst1,&__pyx_n_s_ifst2,&__pyx_n_s_compose_filter,&__pyx_n_s_connect,0}; + PyObject* values[4] = {0,0,0,0}; + values[2] = ((PyObject *)__pyx_n_b_auto); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst1)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst2)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("difference", 0, 2, 4, 1); __PYX_ERR(0, 3441, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_compose_filter); + if (value) { values[2] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_connect); + if (value) { values[3] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "difference") < 0)) __PYX_ERR(0, 3441, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ifst1 = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]); + __pyx_v_ifst2 = ((struct __pyx_obj_9pywrapfst__Fst *)values[1]); + __pyx_v_compose_filter = values[2]; + if (values[3]) { + __pyx_v_connect = __Pyx_PyObject_IsTrue(values[3]); if (unlikely((__pyx_v_connect == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3444, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":3444 + * _Fst ifst2, + * compose_filter=b"auto", + * bool connect=True): # <<<<<<<<<<<<<< + * """ + * difference(ifst1, ifst2, compose_filter="auto", connect=True) + */ + __pyx_v_connect = ((bool)1); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("difference", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3441, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.difference", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst1), __pyx_ptype_9pywrapfst__Fst, 1, "ifst1", 0))) __PYX_ERR(0, 3441, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst2), __pyx_ptype_9pywrapfst__Fst, 1, "ifst2", 0))) __PYX_ERR(0, 3442, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_24difference(__pyx_self, __pyx_v_ifst1, __pyx_v_ifst2, __pyx_v_compose_filter, __pyx_v_connect); + + /* "pywrapfst.pyx":3441 + * + * + * cpdef _MutableFst difference(_Fst ifst1, # <<<<<<<<<<<<<< + * _Fst ifst2, + * compose_filter=b"auto", + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_24difference(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, PyObject *__pyx_v_compose_filter, bool __pyx_v_connect) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + struct __pyx_opt_args_9pywrapfst_difference __pyx_t_2; + __Pyx_RefNannySetupContext("difference", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 2; + __pyx_t_2.compose_filter = __pyx_v_compose_filter; + __pyx_t_2.connect = __pyx_v_connect; + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_difference(__pyx_v_ifst1, __pyx_v_ifst2, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3441, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.difference", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3476 + * + * + * cpdef _MutableFst disambiguate(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * int64 nstate=fst.kNoStateId, + */ + +static PyObject *__pyx_pw_9pywrapfst_27disambiguate(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_disambiguate(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_disambiguate *__pyx_optional_args) { + float __pyx_v_delta = __pyx_k__71; + __pyx_t_10basictypes_int64 __pyx_v_nstate = __pyx_k__72; + __pyx_t_10basictypes_int64 __pyx_v_subsequential_label = ((__pyx_t_10basictypes_int64)0); + + /* "pywrapfst.pyx":3480 + * int64 nstate=fst.kNoStateId, + * int64 subsequential_label=0, + * weight=None): # <<<<<<<<<<<<<< + * """ + * disambiguate(ifst, delta=0.0009765625, nstate=NO_STATE_ID, + */ + PyObject *__pyx_v_weight = ((PyObject *)Py_None); + std::unique_ptr __pyx_v_tfst; + fst::script::WeightClass __pyx_v_wc; + std::unique_ptr __pyx_v_opts; + struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + fst::script::WeightClass __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("disambiguate", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_delta = __pyx_optional_args->delta; + if (__pyx_optional_args->__pyx_n > 1) { + __pyx_v_nstate = __pyx_optional_args->nstate; + if (__pyx_optional_args->__pyx_n > 2) { + __pyx_v_subsequential_label = __pyx_optional_args->subsequential_label; + if (__pyx_optional_args->__pyx_n > 3) { + __pyx_v_weight = __pyx_optional_args->weight; + } + } + } + } + } + + /* "pywrapfst.pyx":3507 + * """ + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) # <<<<<<<<<<<<<< + * # Threshold is set to semiring Zero (no pruning) if no weight is specified. + * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "arc_type"); + __PYX_ERR(0, 3507, __pyx_L1_error) + } + __pyx_v_tfst.reset(new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->arc_type(__pyx_v_ifst, 0))); + + /* "pywrapfst.pyx":3509 + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + * # Threshold is set to semiring Zero (no pruning) if no weight is specified. + * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), # <<<<<<<<<<<<<< + * weight) + * cdef unique_ptr[fst.DisambiguateOptions] opts + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "weight_type"); + __PYX_ERR(0, 3509, __pyx_L1_error) + } + + /* "pywrapfst.pyx":3510 + * # Threshold is set to semiring Zero (no pruning) if no weight is specified. + * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), + * weight) # <<<<<<<<<<<<<< + * cdef unique_ptr[fst.DisambiguateOptions] opts + * opts.reset(new fst.DisambiguateOptions(delta, wc, nstate, + */ + __pyx_t_1 = __pyx_f_9pywrapfst__get_WeightClass_or_Zero(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->weight_type(__pyx_v_ifst, 0), __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3509, __pyx_L1_error) + __pyx_v_wc = __pyx_t_1; + + /* "pywrapfst.pyx":3512 + * weight) + * cdef unique_ptr[fst.DisambiguateOptions] opts + * opts.reset(new fst.DisambiguateOptions(delta, wc, nstate, # <<<<<<<<<<<<<< + * subsequential_label)) + * fst.Disambiguate(deref(ifst._fst), tfst.get(), deref(opts)) + */ + __pyx_v_opts.reset(new fst::script::DisambiguateOptions(__pyx_v_delta, __pyx_v_wc, __pyx_v_nstate, __pyx_v_subsequential_label)); + + /* "pywrapfst.pyx":3514 + * opts.reset(new fst.DisambiguateOptions(delta, wc, nstate, + * subsequential_label)) + * fst.Disambiguate(deref(ifst._fst), tfst.get(), deref(opts)) # <<<<<<<<<<<<<< + * return _init_MutableFst(tfst.release()) + * + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3514, __pyx_L1_error) + } + fst::script::Disambiguate((*__pyx_v_ifst->_fst), __pyx_v_tfst.get(), (*__pyx_v_opts)); + + /* "pywrapfst.pyx":3515 + * subsequential_label)) + * fst.Disambiguate(deref(ifst._fst), tfst.get(), deref(opts)) + * return _init_MutableFst(tfst.release()) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_2 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst.release())); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = ((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_t_2); + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":3476 + * + * + * cpdef _MutableFst disambiguate(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * int64 nstate=fst.kNoStateId, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pywrapfst.disambiguate", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_27disambiguate(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_26disambiguate[] = "\n disambiguate(ifst, delta=0.0009765625, nstate=NO_STATE_ID,\n subsequential_label=0, weight=None):\n\n Constructively disambiguates a weighted transducer.\n\n This operation disambiguates a weighted transducer. The result will be an\n equivalent FST that has the property that no two successful paths have the\n same input labeling. For this algorithm, epsilon transitions are treated as\n regular symbols (cf. `rmepsilon`).\n\n Args:\n ifst: The input FST.\n delta: Comparison/quantization delta.\n nstate: State number threshold.\n subsequential_label: Input label of arc corresponding to residual final\n output when producing a subsequential transducer.\n weight: A Weight or weight string indicating the desired weight threshold\n below which paths are pruned; if omitted, no paths are pruned.\n\n Returns:\n An equivalent disambiguated FST.\n\n See also: `determinize`, `rmepsilon`.\n "; +static PyObject *__pyx_pw_9pywrapfst_27disambiguate(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0; + float __pyx_v_delta; + __pyx_t_10basictypes_int64 __pyx_v_nstate; + __pyx_t_10basictypes_int64 __pyx_v_subsequential_label; + PyObject *__pyx_v_weight = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("disambiguate (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_delta,&__pyx_n_s_nstate,&__pyx_n_s_subsequential_label,&__pyx_n_s_weight,0}; + PyObject* values[5] = {0,0,0,0,0}; + + /* "pywrapfst.pyx":3480 + * int64 nstate=fst.kNoStateId, + * int64 subsequential_label=0, + * weight=None): # <<<<<<<<<<<<<< + * """ + * disambiguate(ifst, delta=0.0009765625, nstate=NO_STATE_ID, + */ + values[4] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta); + if (value) { values[1] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nstate); + if (value) { values[2] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_subsequential_label); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weight); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "disambiguate") < 0)) __PYX_ERR(0, 3476, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ifst = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]); + if (values[1]) { + __pyx_v_delta = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_delta == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3477, __pyx_L3_error) + } else { + __pyx_v_delta = __pyx_k__71; + } + if (values[2]) { + __pyx_v_nstate = __Pyx_PyInt_As_int64_t(values[2]); if (unlikely((__pyx_v_nstate == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3478, __pyx_L3_error) + } else { + __pyx_v_nstate = __pyx_k__72; + } + if (values[3]) { + __pyx_v_subsequential_label = __Pyx_PyInt_As_int64_t(values[3]); if (unlikely((__pyx_v_subsequential_label == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3479, __pyx_L3_error) + } else { + __pyx_v_subsequential_label = ((__pyx_t_10basictypes_int64)0); + } + __pyx_v_weight = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("disambiguate", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3476, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.disambiguate", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst), __pyx_ptype_9pywrapfst__Fst, 1, "ifst", 0))) __PYX_ERR(0, 3476, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_26disambiguate(__pyx_self, __pyx_v_ifst, __pyx_v_delta, __pyx_v_nstate, __pyx_v_subsequential_label, __pyx_v_weight); + + /* "pywrapfst.pyx":3476 + * + * + * cpdef _MutableFst disambiguate(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * int64 nstate=fst.kNoStateId, + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_26disambiguate(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, __pyx_t_10basictypes_int64 __pyx_v_nstate, __pyx_t_10basictypes_int64 __pyx_v_subsequential_label, PyObject *__pyx_v_weight) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + struct __pyx_opt_args_9pywrapfst_disambiguate __pyx_t_2; + __Pyx_RefNannySetupContext("disambiguate", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 4; + __pyx_t_2.delta = __pyx_v_delta; + __pyx_t_2.nstate = __pyx_v_nstate; + __pyx_t_2.subsequential_label = __pyx_v_subsequential_label; + __pyx_t_2.weight = __pyx_v_weight; + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_disambiguate(__pyx_v_ifst, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.disambiguate", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3518 + * + * + * cpdef _MutableFst epsnormalize(_Fst ifst, bool eps_norm_output=False): # <<<<<<<<<<<<<< + * """ + * epsnormalize(ifst, eps_norm_output=False) + */ + +static PyObject *__pyx_pw_9pywrapfst_29epsnormalize(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_epsnormalize(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_epsnormalize *__pyx_optional_args) { + bool __pyx_v_eps_norm_output = ((bool)0); + std::unique_ptr __pyx_v_tfst; + struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + enum fst::EpsNormalizeType __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("epsnormalize", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_eps_norm_output = __pyx_optional_args->eps_norm_output; + } + } + + /* "pywrapfst.pyx":3541 + * """ + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) # <<<<<<<<<<<<<< + * fst.EpsNormalize(deref(ifst._fst), tfst.get(), fst.EPS_NORM_OUTPUT if + * eps_norm_output else + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "arc_type"); + __PYX_ERR(0, 3541, __pyx_L1_error) + } + __pyx_v_tfst.reset(new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->arc_type(__pyx_v_ifst, 0))); + + /* "pywrapfst.pyx":3542 + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + * fst.EpsNormalize(deref(ifst._fst), tfst.get(), fst.EPS_NORM_OUTPUT if # <<<<<<<<<<<<<< + * eps_norm_output else + * fst.EPS_NORM_INPUT) + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3542, __pyx_L1_error) + } + + /* "pywrapfst.pyx":3543 + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + * fst.EpsNormalize(deref(ifst._fst), tfst.get(), fst.EPS_NORM_OUTPUT if + * eps_norm_output else # <<<<<<<<<<<<<< + * fst.EPS_NORM_INPUT) + * return _init_MutableFst(tfst.release()) + */ + if ((__pyx_v_eps_norm_output != 0)) { + + /* "pywrapfst.pyx":3542 + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + * fst.EpsNormalize(deref(ifst._fst), tfst.get(), fst.EPS_NORM_OUTPUT if # <<<<<<<<<<<<<< + * eps_norm_output else + * fst.EPS_NORM_INPUT) + */ + __pyx_t_1 = fst::EPS_NORM_OUTPUT; + } else { + + /* "pywrapfst.pyx":3544 + * fst.EpsNormalize(deref(ifst._fst), tfst.get(), fst.EPS_NORM_OUTPUT if + * eps_norm_output else + * fst.EPS_NORM_INPUT) # <<<<<<<<<<<<<< + * return _init_MutableFst(tfst.release()) + * + */ + __pyx_t_1 = fst::EPS_NORM_INPUT; + } + + /* "pywrapfst.pyx":3542 + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + * fst.EpsNormalize(deref(ifst._fst), tfst.get(), fst.EPS_NORM_OUTPUT if # <<<<<<<<<<<<<< + * eps_norm_output else + * fst.EPS_NORM_INPUT) + */ + fst::script::EpsNormalize((*__pyx_v_ifst->_fst), __pyx_v_tfst.get(), __pyx_t_1); + + /* "pywrapfst.pyx":3545 + * eps_norm_output else + * fst.EPS_NORM_INPUT) + * return _init_MutableFst(tfst.release()) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_2 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst.release())); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = ((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_t_2); + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":3518 + * + * + * cpdef _MutableFst epsnormalize(_Fst ifst, bool eps_norm_output=False): # <<<<<<<<<<<<<< + * """ + * epsnormalize(ifst, eps_norm_output=False) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pywrapfst.epsnormalize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_29epsnormalize(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_28epsnormalize[] = "\n epsnormalize(ifst, eps_norm_output=False)\n\n Constructively epsilon-normalizes an FST.\n\n This operation creates an equivalent FST that is epsilon-normalized. An\n acceptor is epsilon-normalized if it it is epsilon-removed (cf. `rmepsilon`).\n A transducer is input epsilon-normalized if, in addition, along any path, all\n arcs with epsilon input labels follow all arcs with non-epsilon input labels.\n Output epsilon-normalized is defined similarly. The input FST must be\n functional.\n\n Args:\n ifst: The input FST.\n eps_norm_output: Should the FST be output epsilon-normalized?\n\n Returns:\n An equivalent epsilon-normalized FST.\n\n See also: `rmepsilon`.\n "; +static PyObject *__pyx_pw_9pywrapfst_29epsnormalize(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0; + bool __pyx_v_eps_norm_output; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("epsnormalize (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_eps_norm_output,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_eps_norm_output); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "epsnormalize") < 0)) __PYX_ERR(0, 3518, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ifst = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]); + if (values[1]) { + __pyx_v_eps_norm_output = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_eps_norm_output == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3518, __pyx_L3_error) + } else { + __pyx_v_eps_norm_output = ((bool)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("epsnormalize", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3518, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.epsnormalize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst), __pyx_ptype_9pywrapfst__Fst, 1, "ifst", 0))) __PYX_ERR(0, 3518, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_28epsnormalize(__pyx_self, __pyx_v_ifst, __pyx_v_eps_norm_output); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_28epsnormalize(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, bool __pyx_v_eps_norm_output) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + struct __pyx_opt_args_9pywrapfst_epsnormalize __pyx_t_2; + __Pyx_RefNannySetupContext("epsnormalize", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 1; + __pyx_t_2.eps_norm_output = __pyx_v_eps_norm_output; + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_epsnormalize(__pyx_v_ifst, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3518, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.epsnormalize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3548 + * + * + * cpdef bool equal(_Fst ifst1, _Fst ifst2, float delta=fst.kDelta): # <<<<<<<<<<<<<< + * """ + * equal(ifst1, ifst2, delta=0.0009765625) + */ + +static PyObject *__pyx_pw_9pywrapfst_31equal(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static bool __pyx_f_9pywrapfst_equal(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_equal *__pyx_optional_args) { + float __pyx_v_delta = __pyx_k__73; + bool __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("equal", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_delta = __pyx_optional_args->delta; + } + } + + /* "pywrapfst.pyx":3568 + * See also: `equivalent`, `isomorphic`, `randequivalent`. + * """ + * return fst.Equal(deref(ifst1._fst), deref(ifst2._fst), delta) # <<<<<<<<<<<<<< + * + * + */ + if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3568, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_ifst2) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3568, __pyx_L1_error) + } + __pyx_r = fst::script::Equal((*__pyx_v_ifst1->_fst), (*__pyx_v_ifst2->_fst), __pyx_v_delta); + goto __pyx_L0; + + /* "pywrapfst.pyx":3548 + * + * + * cpdef bool equal(_Fst ifst1, _Fst ifst2, float delta=fst.kDelta): # <<<<<<<<<<<<<< + * """ + * equal(ifst1, ifst2, delta=0.0009765625) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("pywrapfst.equal", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_31equal(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_30equal[] = "\n equal(ifst1, ifst2, delta=0.0009765625)\n\n Are two FSTs equal?\n\n This function tests whether two FSTs have the same states with the same\n numbering and the same transitions with the same labels and weights in the\n same order.\n\n Args:\n ifst1: The first input FST.\n ifst2: The second input FST.\n delta: Comparison/quantization delta.\n\n Returns:\n True if the FSTs satisfy the above condition, else False.\n\n See also: `equivalent`, `isomorphic`, `randequivalent`.\n "; +static PyObject *__pyx_pw_9pywrapfst_31equal(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1 = 0; + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2 = 0; + float __pyx_v_delta; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("equal (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst1,&__pyx_n_s_ifst2,&__pyx_n_s_delta,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst1)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst2)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("equal", 0, 2, 3, 1); __PYX_ERR(0, 3548, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "equal") < 0)) __PYX_ERR(0, 3548, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ifst1 = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]); + __pyx_v_ifst2 = ((struct __pyx_obj_9pywrapfst__Fst *)values[1]); + if (values[2]) { + __pyx_v_delta = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_delta == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3548, __pyx_L3_error) + } else { + __pyx_v_delta = __pyx_k__73; + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("equal", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3548, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.equal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst1), __pyx_ptype_9pywrapfst__Fst, 1, "ifst1", 0))) __PYX_ERR(0, 3548, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst2), __pyx_ptype_9pywrapfst__Fst, 1, "ifst2", 0))) __PYX_ERR(0, 3548, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_30equal(__pyx_self, __pyx_v_ifst1, __pyx_v_ifst2, __pyx_v_delta); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_30equal(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, float __pyx_v_delta) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + bool __pyx_t_1; + struct __pyx_opt_args_9pywrapfst_equal __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("equal", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 1; + __pyx_t_2.delta = __pyx_v_delta; + __pyx_t_1 = __pyx_f_9pywrapfst_equal(__pyx_v_ifst1, __pyx_v_ifst2, 0, &__pyx_t_2); + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3548, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pywrapfst.equal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3571 + * + * + * cpdef bool equivalent(_Fst ifst1, _Fst ifst2, float delta=fst.kDelta) except *: # <<<<<<<<<<<<<< + * """ + * equivalent(ifst1, ifst2, delta=0.0009765625) + */ + +static PyObject *__pyx_pw_9pywrapfst_33equivalent(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static bool __pyx_f_9pywrapfst_equivalent(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_equivalent *__pyx_optional_args) { + float __pyx_v_delta = __pyx_k__74; + bool __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("equivalent", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_delta = __pyx_optional_args->delta; + } + } + + /* "pywrapfst.pyx":3591 + * See also: `equal`, `isomorphic`, `randequivalent`. + * """ + * return fst.Equivalent(deref(ifst1._fst), deref(ifst2._fst), delta) # <<<<<<<<<<<<<< + * + * + */ + if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3591, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_ifst2) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3591, __pyx_L1_error) + } + __pyx_r = fst::script::Equivalent((*__pyx_v_ifst1->_fst), (*__pyx_v_ifst2->_fst), __pyx_v_delta); + goto __pyx_L0; + + /* "pywrapfst.pyx":3571 + * + * + * cpdef bool equivalent(_Fst ifst1, _Fst ifst2, float delta=fst.kDelta) except *: # <<<<<<<<<<<<<< + * """ + * equivalent(ifst1, ifst2, delta=0.0009765625) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst.equivalent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_33equivalent(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_32equivalent[] = "\n equivalent(ifst1, ifst2, delta=0.0009765625)\n\n Are the two acceptors equivalent?\n\n This operation tests whether two epsilon-free deterministic weighted\n acceptors are equivalent, that is if they accept the same strings with the\n same weights.\n\n Args:\n ifst1: The first input FST.\n ifst2: The second input FST.\n delta: Comparison/quantization delta.\n\n Returns:\n True if the FSTs satisfy the above condition, else False.\n\n See also: `equal`, `isomorphic`, `randequivalent`.\n "; +static PyObject *__pyx_pw_9pywrapfst_33equivalent(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1 = 0; + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2 = 0; + float __pyx_v_delta; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("equivalent (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst1,&__pyx_n_s_ifst2,&__pyx_n_s_delta,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst1)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst2)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("equivalent", 0, 2, 3, 1); __PYX_ERR(0, 3571, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "equivalent") < 0)) __PYX_ERR(0, 3571, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ifst1 = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]); + __pyx_v_ifst2 = ((struct __pyx_obj_9pywrapfst__Fst *)values[1]); + if (values[2]) { + __pyx_v_delta = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_delta == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3571, __pyx_L3_error) + } else { + __pyx_v_delta = __pyx_k__74; + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("equivalent", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3571, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.equivalent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst1), __pyx_ptype_9pywrapfst__Fst, 1, "ifst1", 0))) __PYX_ERR(0, 3571, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst2), __pyx_ptype_9pywrapfst__Fst, 1, "ifst2", 0))) __PYX_ERR(0, 3571, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_32equivalent(__pyx_self, __pyx_v_ifst1, __pyx_v_ifst2, __pyx_v_delta); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_32equivalent(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, float __pyx_v_delta) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + bool __pyx_t_1; + struct __pyx_opt_args_9pywrapfst_equivalent __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("equivalent", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 1; + __pyx_t_2.delta = __pyx_v_delta; + __pyx_t_1 = __pyx_f_9pywrapfst_equivalent(__pyx_v_ifst1, __pyx_v_ifst2, 0, &__pyx_t_2); if (unlikely(__pyx_t_1 == ((bool)-1) && PyErr_Occurred())) __PYX_ERR(0, 3571, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3571, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pywrapfst.equivalent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3594 + * + * + * cpdef _MutableFst intersect(_Fst ifst1, # <<<<<<<<<<<<<< + * _Fst ifst2, + * compose_filter=b"auto", + */ + +static PyObject *__pyx_pw_9pywrapfst_35intersect(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_intersect(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_intersect *__pyx_optional_args) { + PyObject *__pyx_v_compose_filter = ((PyObject *)__pyx_n_b_auto); + + /* "pywrapfst.pyx":3597 + * _Fst ifst2, + * compose_filter=b"auto", + * bool connect=True): # <<<<<<<<<<<<<< + * """ + * intersect(ifst1, ifst2, compose_filter="auto", connect=True) + */ + bool __pyx_v_connect = ((bool)1); + std::unique_ptr __pyx_v_tfst; + std::unique_ptr __pyx_v_opts; + struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + std::string __pyx_t_1; + enum fst::ComposeFilter __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("intersect", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_compose_filter = __pyx_optional_args->compose_filter; + if (__pyx_optional_args->__pyx_n > 1) { + __pyx_v_connect = __pyx_optional_args->connect; + } + } + } + + /* "pywrapfst.pyx":3619 + * """ + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst1.arc_type())) # <<<<<<<<<<<<<< + * cdef unique_ptr[fst.ComposeOptions] opts + * opts.reset(new fst.ComposeOptions(connect, + */ + if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "arc_type"); + __PYX_ERR(0, 3619, __pyx_L1_error) + } + __pyx_v_tfst.reset(new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst1->__pyx_vtab)->arc_type(__pyx_v_ifst1, 0))); + + /* "pywrapfst.pyx":3622 + * cdef unique_ptr[fst.ComposeOptions] opts + * opts.reset(new fst.ComposeOptions(connect, + * _get_compose_filter(tostring(compose_filter)))) # <<<<<<<<<<<<<< + * fst.Intersect(deref(ifst1._fst), deref(ifst2._fst), tfst.get(), deref(opts)) + * return _init_MutableFst(tfst.release()) + */ + __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_compose_filter, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3622, __pyx_L1_error) + __pyx_t_2 = __pyx_f_9pywrapfst__get_compose_filter(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3622, __pyx_L1_error) + + /* "pywrapfst.pyx":3621 + * tfst.reset(new fst.VectorFstClass(ifst1.arc_type())) + * cdef unique_ptr[fst.ComposeOptions] opts + * opts.reset(new fst.ComposeOptions(connect, # <<<<<<<<<<<<<< + * _get_compose_filter(tostring(compose_filter)))) + * fst.Intersect(deref(ifst1._fst), deref(ifst2._fst), tfst.get(), deref(opts)) + */ + __pyx_v_opts.reset(new fst::ComposeOptions(__pyx_v_connect, __pyx_t_2)); + + /* "pywrapfst.pyx":3623 + * opts.reset(new fst.ComposeOptions(connect, + * _get_compose_filter(tostring(compose_filter)))) + * fst.Intersect(deref(ifst1._fst), deref(ifst2._fst), tfst.get(), deref(opts)) # <<<<<<<<<<<<<< + * return _init_MutableFst(tfst.release()) + * + */ + if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3623, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_ifst2) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3623, __pyx_L1_error) + } + fst::script::Intersect((*__pyx_v_ifst1->_fst), (*__pyx_v_ifst2->_fst), __pyx_v_tfst.get(), (*__pyx_v_opts)); + + /* "pywrapfst.pyx":3624 + * _get_compose_filter(tostring(compose_filter)))) + * fst.Intersect(deref(ifst1._fst), deref(ifst2._fst), tfst.get(), deref(opts)) + * return _init_MutableFst(tfst.release()) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst.release())); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3624, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = ((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":3594 + * + * + * cpdef _MutableFst intersect(_Fst ifst1, # <<<<<<<<<<<<<< + * _Fst ifst2, + * compose_filter=b"auto", + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pywrapfst.intersect", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_35intersect(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_34intersect[] = "\n intersect(ifst1, ifst2, compose_filter=\"auto\", connect=True)\n\n Constructively intersects two FSTs.\n\n This operation computes the intersection (Hadamard product) of two FSTs.\n Only strings that are in both automata are retained in the result. The two\n arguments must be acceptors. One of the arguments must be label-sorted (or\n otherwise support appropriate matchers).\n\n Args:\n ifst1: The first input FST.\n ifst2: The second input FST.\n compose_filter: A string matching a known composition filter; one of:\n \"alt_sequence\", \"auto\", \"match\", \"null\", \"sequence\", \"trivial\".\n connect: Should output be trimmed?\n\n Returns:\n An intersected FST.\n "; +static PyObject *__pyx_pw_9pywrapfst_35intersect(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1 = 0; + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2 = 0; + PyObject *__pyx_v_compose_filter = 0; + bool __pyx_v_connect; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("intersect (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst1,&__pyx_n_s_ifst2,&__pyx_n_s_compose_filter,&__pyx_n_s_connect,0}; + PyObject* values[4] = {0,0,0,0}; + values[2] = ((PyObject *)__pyx_n_b_auto); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst1)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst2)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("intersect", 0, 2, 4, 1); __PYX_ERR(0, 3594, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_compose_filter); + if (value) { values[2] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_connect); + if (value) { values[3] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "intersect") < 0)) __PYX_ERR(0, 3594, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ifst1 = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]); + __pyx_v_ifst2 = ((struct __pyx_obj_9pywrapfst__Fst *)values[1]); + __pyx_v_compose_filter = values[2]; + if (values[3]) { + __pyx_v_connect = __Pyx_PyObject_IsTrue(values[3]); if (unlikely((__pyx_v_connect == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3597, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":3597 + * _Fst ifst2, + * compose_filter=b"auto", + * bool connect=True): # <<<<<<<<<<<<<< + * """ + * intersect(ifst1, ifst2, compose_filter="auto", connect=True) + */ + __pyx_v_connect = ((bool)1); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("intersect", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3594, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.intersect", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst1), __pyx_ptype_9pywrapfst__Fst, 1, "ifst1", 0))) __PYX_ERR(0, 3594, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst2), __pyx_ptype_9pywrapfst__Fst, 1, "ifst2", 0))) __PYX_ERR(0, 3595, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_34intersect(__pyx_self, __pyx_v_ifst1, __pyx_v_ifst2, __pyx_v_compose_filter, __pyx_v_connect); + + /* "pywrapfst.pyx":3594 + * + * + * cpdef _MutableFst intersect(_Fst ifst1, # <<<<<<<<<<<<<< + * _Fst ifst2, + * compose_filter=b"auto", + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_34intersect(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, PyObject *__pyx_v_compose_filter, bool __pyx_v_connect) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + struct __pyx_opt_args_9pywrapfst_intersect __pyx_t_2; + __Pyx_RefNannySetupContext("intersect", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 2; + __pyx_t_2.compose_filter = __pyx_v_compose_filter; + __pyx_t_2.connect = __pyx_v_connect; + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_intersect(__pyx_v_ifst1, __pyx_v_ifst2, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3594, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.intersect", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3627 + * + * + * cpdef bool isomorphic(_Fst ifst1, _Fst ifst2, float delta=fst.kDelta): # <<<<<<<<<<<<<< + * """ + * isomorphic(ifst1, ifst2, delta=0.0009765625) + */ + +static PyObject *__pyx_pw_9pywrapfst_37isomorphic(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static bool __pyx_f_9pywrapfst_isomorphic(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_isomorphic *__pyx_optional_args) { + float __pyx_v_delta = __pyx_k__75; + bool __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isomorphic", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_delta = __pyx_optional_args->delta; + } + } + + /* "pywrapfst.pyx":3650 + * See also: `equal`, `equivalent`, `randequivalent`. + * """ + * return fst.Isomorphic(deref(ifst1._fst), deref(ifst2._fst), delta) # <<<<<<<<<<<<<< + * + * + */ + if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3650, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_ifst2) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3650, __pyx_L1_error) + } + __pyx_r = fst::script::Isomorphic((*__pyx_v_ifst1->_fst), (*__pyx_v_ifst2->_fst), __pyx_v_delta); + goto __pyx_L0; + + /* "pywrapfst.pyx":3627 + * + * + * cpdef bool isomorphic(_Fst ifst1, _Fst ifst2, float delta=fst.kDelta): # <<<<<<<<<<<<<< + * """ + * isomorphic(ifst1, ifst2, delta=0.0009765625) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("pywrapfst.isomorphic", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_37isomorphic(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_36isomorphic[] = "\n isomorphic(ifst1, ifst2, delta=0.0009765625)\n\n Are the two acceptors isomorphic?\n\n This operation determines if two transducers with a certain required\n determinism have the same states, irrespective of numbering, and the same\n transitions with the same labels and weights, irrespective of ordering. In\n other words, FSTs A, B are isomorphic if and only if the states of A can be\n renumbered and the transitions leaving each state reordered so the two are\n equal (according to the definition given in `equal`).\n\n Args:\n ifst1: The first input FST.\n ifst2: The second input FST.\n delta: Comparison/quantization delta.\n\n Returns:\n True if the two transducers satisfy the above condition, else False.\n\n See also: `equal`, `equivalent`, `randequivalent`.\n "; +static PyObject *__pyx_pw_9pywrapfst_37isomorphic(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1 = 0; + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2 = 0; + float __pyx_v_delta; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isomorphic (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst1,&__pyx_n_s_ifst2,&__pyx_n_s_delta,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst1)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst2)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("isomorphic", 0, 2, 3, 1); __PYX_ERR(0, 3627, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "isomorphic") < 0)) __PYX_ERR(0, 3627, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ifst1 = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]); + __pyx_v_ifst2 = ((struct __pyx_obj_9pywrapfst__Fst *)values[1]); + if (values[2]) { + __pyx_v_delta = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_delta == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3627, __pyx_L3_error) + } else { + __pyx_v_delta = __pyx_k__75; + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("isomorphic", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3627, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.isomorphic", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst1), __pyx_ptype_9pywrapfst__Fst, 1, "ifst1", 0))) __PYX_ERR(0, 3627, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst2), __pyx_ptype_9pywrapfst__Fst, 1, "ifst2", 0))) __PYX_ERR(0, 3627, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_36isomorphic(__pyx_self, __pyx_v_ifst1, __pyx_v_ifst2, __pyx_v_delta); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_36isomorphic(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, float __pyx_v_delta) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + bool __pyx_t_1; + struct __pyx_opt_args_9pywrapfst_isomorphic __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("isomorphic", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 1; + __pyx_t_2.delta = __pyx_v_delta; + __pyx_t_1 = __pyx_f_9pywrapfst_isomorphic(__pyx_v_ifst1, __pyx_v_ifst2, 0, &__pyx_t_2); + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3627, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pywrapfst.isomorphic", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3653 + * + * + * cpdef _MutableFst prune(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * int64 nstate=fst.kNoStateId, + */ + +static PyObject *__pyx_pw_9pywrapfst_39prune(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_prune(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_prune *__pyx_optional_args) { + float __pyx_v_delta = __pyx_k__76; + __pyx_t_10basictypes_int64 __pyx_v_nstate = __pyx_k__77; + + /* "pywrapfst.pyx":3656 + * float delta=fst.kDelta, + * int64 nstate=fst.kNoStateId, + * weight=None): # <<<<<<<<<<<<<< + * """ + * prune(ifst, delta=0.0009765625, nstate=NO_STATE_ID, weight=None) + */ + PyObject *__pyx_v_weight = ((PyObject *)Py_None); + std::unique_ptr __pyx_v_tfst; + fst::script::WeightClass __pyx_v_wc; + struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + fst::script::WeightClass __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("prune", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_delta = __pyx_optional_args->delta; + if (__pyx_optional_args->__pyx_n > 1) { + __pyx_v_nstate = __pyx_optional_args->nstate; + if (__pyx_optional_args->__pyx_n > 2) { + __pyx_v_weight = __pyx_optional_args->weight; + } + } + } + } + + /* "pywrapfst.pyx":3680 + * """ + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) # <<<<<<<<<<<<<< + * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), weight) + * fst.Prune(deref(ifst._fst), tfst.get(), wc, nstate, delta) + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "arc_type"); + __PYX_ERR(0, 3680, __pyx_L1_error) + } + __pyx_v_tfst.reset(new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->arc_type(__pyx_v_ifst, 0))); + + /* "pywrapfst.pyx":3681 + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), weight) # <<<<<<<<<<<<<< + * fst.Prune(deref(ifst._fst), tfst.get(), wc, nstate, delta) + * return _init_MutableFst(tfst.release()) + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "weight_type"); + __PYX_ERR(0, 3681, __pyx_L1_error) + } + __pyx_t_1 = __pyx_f_9pywrapfst__get_WeightClass_or_Zero(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->weight_type(__pyx_v_ifst, 0), __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3681, __pyx_L1_error) + __pyx_v_wc = __pyx_t_1; + + /* "pywrapfst.pyx":3682 + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), weight) + * fst.Prune(deref(ifst._fst), tfst.get(), wc, nstate, delta) # <<<<<<<<<<<<<< + * return _init_MutableFst(tfst.release()) + * + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3682, __pyx_L1_error) + } + fst::script::Prune((*__pyx_v_ifst->_fst), __pyx_v_tfst.get(), __pyx_v_wc, __pyx_v_nstate, __pyx_v_delta); + + /* "pywrapfst.pyx":3683 + * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), weight) + * fst.Prune(deref(ifst._fst), tfst.get(), wc, nstate, delta) + * return _init_MutableFst(tfst.release()) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_2 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst.release())); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3683, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = ((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_t_2); + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":3653 + * + * + * cpdef _MutableFst prune(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * int64 nstate=fst.kNoStateId, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pywrapfst.prune", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_39prune(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_38prune[] = "\n prune(ifst, delta=0.0009765625, nstate=NO_STATE_ID, weight=None)\n\n Constructively removes paths with weights below a certain threshold.\n\n This operation deletes states and arcs in the input FST that do not belong\n to a successful path whose weight is no more (w.r.t the natural semiring\n order) than the threshold t \\otimes-times the weight of the shortest path in\n the input FST. Weights must be commutative and have the path property.\n\n Args:\n ifst: The input FST.\n delta: Comparison/quantization delta.\n nstate: State number threshold.\n weight: A Weight or weight string indicating the desired weight threshold\n below which paths are pruned; if omitted, no paths are pruned.\n\n Returns:\n A pruned FST.\n\n See also: The destructive variant.\n "; +static PyObject *__pyx_pw_9pywrapfst_39prune(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0; + float __pyx_v_delta; + __pyx_t_10basictypes_int64 __pyx_v_nstate; + PyObject *__pyx_v_weight = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("prune (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_delta,&__pyx_n_s_nstate,&__pyx_n_s_weight,0}; + PyObject* values[4] = {0,0,0,0}; + + /* "pywrapfst.pyx":3656 + * float delta=fst.kDelta, + * int64 nstate=fst.kNoStateId, + * weight=None): # <<<<<<<<<<<<<< + * """ + * prune(ifst, delta=0.0009765625, nstate=NO_STATE_ID, weight=None) + */ + values[3] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta); + if (value) { values[1] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nstate); + if (value) { values[2] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weight); + if (value) { values[3] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "prune") < 0)) __PYX_ERR(0, 3653, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ifst = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]); + if (values[1]) { + __pyx_v_delta = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_delta == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3654, __pyx_L3_error) + } else { + __pyx_v_delta = __pyx_k__76; + } + if (values[2]) { + __pyx_v_nstate = __Pyx_PyInt_As_int64_t(values[2]); if (unlikely((__pyx_v_nstate == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3655, __pyx_L3_error) + } else { + __pyx_v_nstate = __pyx_k__77; + } + __pyx_v_weight = values[3]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("prune", 0, 1, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3653, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.prune", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst), __pyx_ptype_9pywrapfst__Fst, 1, "ifst", 0))) __PYX_ERR(0, 3653, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_38prune(__pyx_self, __pyx_v_ifst, __pyx_v_delta, __pyx_v_nstate, __pyx_v_weight); + + /* "pywrapfst.pyx":3653 + * + * + * cpdef _MutableFst prune(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * int64 nstate=fst.kNoStateId, + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_38prune(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, __pyx_t_10basictypes_int64 __pyx_v_nstate, PyObject *__pyx_v_weight) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + struct __pyx_opt_args_9pywrapfst_prune __pyx_t_2; + __Pyx_RefNannySetupContext("prune", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 3; + __pyx_t_2.delta = __pyx_v_delta; + __pyx_t_2.nstate = __pyx_v_nstate; + __pyx_t_2.weight = __pyx_v_weight; + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_prune(__pyx_v_ifst, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3653, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.prune", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3686 + * + * + * cpdef _MutableFst push(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * bool push_weights=False, + */ + +static PyObject *__pyx_pw_9pywrapfst_41push(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_push(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_push *__pyx_optional_args) { + float __pyx_v_delta = __pyx_k__78; + + /* "pywrapfst.pyx":3688 + * cpdef _MutableFst push(_Fst ifst, + * float delta=fst.kDelta, + * bool push_weights=False, # <<<<<<<<<<<<<< + * bool push_labels=False, + * bool remove_common_affix=False, + */ + bool __pyx_v_push_weights = ((bool)0); + + /* "pywrapfst.pyx":3689 + * float delta=fst.kDelta, + * bool push_weights=False, + * bool push_labels=False, # <<<<<<<<<<<<<< + * bool remove_common_affix=False, + * bool remove_total_weight=False, + */ + bool __pyx_v_push_labels = ((bool)0); + + /* "pywrapfst.pyx":3690 + * bool push_weights=False, + * bool push_labels=False, + * bool remove_common_affix=False, # <<<<<<<<<<<<<< + * bool remove_total_weight=False, + * bool to_final=False): + */ + bool __pyx_v_remove_common_affix = ((bool)0); + + /* "pywrapfst.pyx":3691 + * bool push_labels=False, + * bool remove_common_affix=False, + * bool remove_total_weight=False, # <<<<<<<<<<<<<< + * bool to_final=False): + * """ + */ + bool __pyx_v_remove_total_weight = ((bool)0); + + /* "pywrapfst.pyx":3692 + * bool remove_common_affix=False, + * bool remove_total_weight=False, + * bool to_final=False): # <<<<<<<<<<<<<< + * """ + * push(ifst, delta=0.0009765625, push_weights=False, push_labels=False, + */ + bool __pyx_v_to_final = ((bool)0); + std::unique_ptr __pyx_v_tfst; + __pyx_t_10basictypes_uint32 __pyx_v_flags; + struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("push", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_delta = __pyx_optional_args->delta; + if (__pyx_optional_args->__pyx_n > 1) { + __pyx_v_push_weights = __pyx_optional_args->push_weights; + if (__pyx_optional_args->__pyx_n > 2) { + __pyx_v_push_labels = __pyx_optional_args->push_labels; + if (__pyx_optional_args->__pyx_n > 3) { + __pyx_v_remove_common_affix = __pyx_optional_args->remove_common_affix; + if (__pyx_optional_args->__pyx_n > 4) { + __pyx_v_remove_total_weight = __pyx_optional_args->remove_total_weight; + if (__pyx_optional_args->__pyx_n > 5) { + __pyx_v_to_final = __pyx_optional_args->to_final; + } + } + } + } + } + } + } + + /* "pywrapfst.pyx":3732 + * # This is copied, almost verbatim, from nlp/fst/bin/fstpush.cc. + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) # <<<<<<<<<<<<<< + * cdef uint32 flags = fst.GetPushFlags(push_weights, push_labels, + * remove_common_affix, remove_total_weight) + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "arc_type"); + __PYX_ERR(0, 3732, __pyx_L1_error) + } + __pyx_v_tfst.reset(new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->arc_type(__pyx_v_ifst, 0))); + + /* "pywrapfst.pyx":3733 + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + * cdef uint32 flags = fst.GetPushFlags(push_weights, push_labels, # <<<<<<<<<<<<<< + * remove_common_affix, remove_total_weight) + * fst.Push(deref(ifst._fst), tfst.get(), flags, fst.GetReweightType(to_final), + */ + __pyx_v_flags = fst::script::GetPushFlags(__pyx_v_push_weights, __pyx_v_push_labels, __pyx_v_remove_common_affix, __pyx_v_remove_total_weight); + + /* "pywrapfst.pyx":3735 + * cdef uint32 flags = fst.GetPushFlags(push_weights, push_labels, + * remove_common_affix, remove_total_weight) + * fst.Push(deref(ifst._fst), tfst.get(), flags, fst.GetReweightType(to_final), # <<<<<<<<<<<<<< + * delta) + * return _init_MutableFst(tfst.release()) + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3735, __pyx_L1_error) + } + + /* "pywrapfst.pyx":3736 + * remove_common_affix, remove_total_weight) + * fst.Push(deref(ifst._fst), tfst.get(), flags, fst.GetReweightType(to_final), + * delta) # <<<<<<<<<<<<<< + * return _init_MutableFst(tfst.release()) + * + */ + fst::script::Push((*__pyx_v_ifst->_fst), __pyx_v_tfst.get(), __pyx_v_flags, fst::script::GetReweightType(__pyx_v_to_final), __pyx_v_delta); + + /* "pywrapfst.pyx":3737 + * fst.Push(deref(ifst._fst), tfst.get(), flags, fst.GetReweightType(to_final), + * delta) + * return _init_MutableFst(tfst.release()) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst.release())); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3737, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = ((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":3686 + * + * + * cpdef _MutableFst push(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * bool push_weights=False, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.push", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_41push(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_40push[] = "\n push(ifst, delta=0.0009765625, push_weights=False, push_labels=False,\n remove_common_affix=False, remove_total_weight=False, to_final=False)\n\n Constructively pushes weights/labels towards initial or final states.\n\n This operation produces an equivalent transducer by pushing the weights\n and/or the labels towards the initial state or toward the final states.\n\n When pushing weights towards the initial state, the sum of the weight of the\n outgoing transitions and final weight at any non-initial state is equal to 1\n in the resulting machine. When pushing weights towards the final states, the\n sum of the weight of the incoming transitions at any state is equal to 1.\n Weights need to be left distributive when pushing towards the initial state\n and right distributive when pushing towards the final states.\n\n Pushing labels towards the initial state consists in minimizing at every\n state the length of the longest common prefix of the output labels of the\n outgoing paths. Pushing labels towards the final states consists in\n minimizing at every state the length of the longest common suffix of the\n output labels of the incoming paths.\n\n Args:\n ifst: The input FST.\n delta: Comparison/quantization delta.\n push_weights: Should weights be pushed?\n push_labels: Should labels be pushed?\n remove_common_affix: If pushing labels, should common prefix/suffix be\n removed?\n remove_total_weight: If pushing weights, should total weight be removed?\n to_final: Push towards final states?\n\n Returns:\n An equivalent pushed FST.\n\n See also: The destructive variant.\n "; +static PyObject *__pyx_pw_9pywrapfst_41push(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0; + float __pyx_v_delta; + bool __pyx_v_push_weights; + bool __pyx_v_push_labels; + bool __pyx_v_remove_common_affix; + bool __pyx_v_remove_total_weight; + bool __pyx_v_to_final; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("push (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_delta,&__pyx_n_s_push_weights,&__pyx_n_s_push_labels,&__pyx_n_s_remove_common_affix,&__pyx_n_s_remove_total_weight,&__pyx_n_s_to_final,0}; + PyObject* values[7] = {0,0,0,0,0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta); + if (value) { values[1] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_push_weights); + if (value) { values[2] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_push_labels); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_remove_common_affix); + if (value) { values[4] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_remove_total_weight); + if (value) { values[5] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_to_final); + if (value) { values[6] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "push") < 0)) __PYX_ERR(0, 3686, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ifst = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]); + if (values[1]) { + __pyx_v_delta = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_delta == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3687, __pyx_L3_error) + } else { + __pyx_v_delta = __pyx_k__78; + } + if (values[2]) { + __pyx_v_push_weights = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_push_weights == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3688, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":3688 + * cpdef _MutableFst push(_Fst ifst, + * float delta=fst.kDelta, + * bool push_weights=False, # <<<<<<<<<<<<<< + * bool push_labels=False, + * bool remove_common_affix=False, + */ + __pyx_v_push_weights = ((bool)0); + } + if (values[3]) { + __pyx_v_push_labels = __Pyx_PyObject_IsTrue(values[3]); if (unlikely((__pyx_v_push_labels == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3689, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":3689 + * float delta=fst.kDelta, + * bool push_weights=False, + * bool push_labels=False, # <<<<<<<<<<<<<< + * bool remove_common_affix=False, + * bool remove_total_weight=False, + */ + __pyx_v_push_labels = ((bool)0); + } + if (values[4]) { + __pyx_v_remove_common_affix = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_remove_common_affix == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3690, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":3690 + * bool push_weights=False, + * bool push_labels=False, + * bool remove_common_affix=False, # <<<<<<<<<<<<<< + * bool remove_total_weight=False, + * bool to_final=False): + */ + __pyx_v_remove_common_affix = ((bool)0); + } + if (values[5]) { + __pyx_v_remove_total_weight = __Pyx_PyObject_IsTrue(values[5]); if (unlikely((__pyx_v_remove_total_weight == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3691, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":3691 + * bool push_labels=False, + * bool remove_common_affix=False, + * bool remove_total_weight=False, # <<<<<<<<<<<<<< + * bool to_final=False): + * """ + */ + __pyx_v_remove_total_weight = ((bool)0); + } + if (values[6]) { + __pyx_v_to_final = __Pyx_PyObject_IsTrue(values[6]); if (unlikely((__pyx_v_to_final == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3692, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":3692 + * bool remove_common_affix=False, + * bool remove_total_weight=False, + * bool to_final=False): # <<<<<<<<<<<<<< + * """ + * push(ifst, delta=0.0009765625, push_weights=False, push_labels=False, + */ + __pyx_v_to_final = ((bool)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("push", 0, 1, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3686, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.push", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst), __pyx_ptype_9pywrapfst__Fst, 1, "ifst", 0))) __PYX_ERR(0, 3686, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_40push(__pyx_self, __pyx_v_ifst, __pyx_v_delta, __pyx_v_push_weights, __pyx_v_push_labels, __pyx_v_remove_common_affix, __pyx_v_remove_total_weight, __pyx_v_to_final); + + /* "pywrapfst.pyx":3686 + * + * + * cpdef _MutableFst push(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * bool push_weights=False, + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_40push(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, bool __pyx_v_push_weights, bool __pyx_v_push_labels, bool __pyx_v_remove_common_affix, bool __pyx_v_remove_total_weight, bool __pyx_v_to_final) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + struct __pyx_opt_args_9pywrapfst_push __pyx_t_2; + __Pyx_RefNannySetupContext("push", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 6; + __pyx_t_2.delta = __pyx_v_delta; + __pyx_t_2.push_weights = __pyx_v_push_weights; + __pyx_t_2.push_labels = __pyx_v_push_labels; + __pyx_t_2.remove_common_affix = __pyx_v_remove_common_affix; + __pyx_t_2.remove_total_weight = __pyx_v_remove_total_weight; + __pyx_t_2.to_final = __pyx_v_to_final; + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_push(__pyx_v_ifst, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3686, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.push", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3740 + * + * + * cpdef bool randequivalent(_Fst ifst1, # <<<<<<<<<<<<<< + * _Fst ifst2, + * int32 npath=1, + */ + +static PyObject *__pyx_pw_9pywrapfst_43randequivalent(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static bool __pyx_f_9pywrapfst_randequivalent(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_randequivalent *__pyx_optional_args) { + __pyx_t_10basictypes_int32 __pyx_v_npath = ((__pyx_t_10basictypes_int32)1); + float __pyx_v_delta = __pyx_k__79; + time_t __pyx_v_seed = ((time_t)0); + PyObject *__pyx_v_select = ((PyObject *)__pyx_n_b_uniform); + __pyx_t_10basictypes_int32 __pyx_v_max_length = __pyx_k__80; + enum fst::script::RandArcSelection __pyx_v_ras; + std::unique_ptr > __pyx_v_opts; + bool __pyx_r; + __Pyx_RefNannyDeclarations + std::string __pyx_t_1; + enum fst::script::RandArcSelection __pyx_t_2; + int __pyx_t_3; + __Pyx_RefNannySetupContext("randequivalent", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_npath = __pyx_optional_args->npath; + if (__pyx_optional_args->__pyx_n > 1) { + __pyx_v_delta = __pyx_optional_args->delta; + if (__pyx_optional_args->__pyx_n > 2) { + __pyx_v_seed = __pyx_optional_args->seed; + if (__pyx_optional_args->__pyx_n > 3) { + __pyx_v_select = __pyx_optional_args->select; + if (__pyx_optional_args->__pyx_n > 4) { + __pyx_v_max_length = __pyx_optional_args->max_length; + } + } + } + } + } + } + + /* "pywrapfst.pyx":3775 + * See also: `equal`, `equivalent`, `isomorphic`, `randgen`. + * """ + * cdef fst.RandArcSelection ras = _get_rand_arc_selection(tostring(select)) # <<<<<<<<<<<<<< + * cdef unique_ptr[fst.RandGenOptions[fst.RandArcSelection]] opts + * # The three trailing options will be ignored by RandEquivalent. + */ + __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_select, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3775, __pyx_L1_error) + __pyx_t_2 = __pyx_f_9pywrapfst__get_rand_arc_selection(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3775, __pyx_L1_error) + __pyx_v_ras = __pyx_t_2; + + /* "pywrapfst.pyx":3778 + * cdef unique_ptr[fst.RandGenOptions[fst.RandArcSelection]] opts + * # The three trailing options will be ignored by RandEquivalent. + * opts.reset(new fst.RandGenOptions[fst.RandArcSelection](ras, max_length, # <<<<<<<<<<<<<< + * 1, False, False)) + * if seed == 0: + */ + __pyx_v_opts.reset(new fst::RandGenOptions (__pyx_v_ras, __pyx_v_max_length, 1, 0, 0)); + + /* "pywrapfst.pyx":3780 + * opts.reset(new fst.RandGenOptions[fst.RandArcSelection](ras, max_length, + * 1, False, False)) + * if seed == 0: # <<<<<<<<<<<<<< + * seed = time(NULL) + getpid() + * return fst.RandEquivalent(deref(ifst1._fst), deref(ifst2._fst), npath, delta, + */ + __pyx_t_3 = ((__pyx_v_seed == 0) != 0); + if (__pyx_t_3) { + + /* "pywrapfst.pyx":3781 + * 1, False, False)) + * if seed == 0: + * seed = time(NULL) + getpid() # <<<<<<<<<<<<<< + * return fst.RandEquivalent(deref(ifst1._fst), deref(ifst2._fst), npath, delta, + * seed, deref(opts)) + */ + __pyx_v_seed = (time(NULL) + getpid()); + + /* "pywrapfst.pyx":3780 + * opts.reset(new fst.RandGenOptions[fst.RandArcSelection](ras, max_length, + * 1, False, False)) + * if seed == 0: # <<<<<<<<<<<<<< + * seed = time(NULL) + getpid() + * return fst.RandEquivalent(deref(ifst1._fst), deref(ifst2._fst), npath, delta, + */ + } + + /* "pywrapfst.pyx":3782 + * if seed == 0: + * seed = time(NULL) + getpid() + * return fst.RandEquivalent(deref(ifst1._fst), deref(ifst2._fst), npath, delta, # <<<<<<<<<<<<<< + * seed, deref(opts)) + * + */ + if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3782, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_ifst2) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3782, __pyx_L1_error) + } + + /* "pywrapfst.pyx":3783 + * seed = time(NULL) + getpid() + * return fst.RandEquivalent(deref(ifst1._fst), deref(ifst2._fst), npath, delta, + * seed, deref(opts)) # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = fst::script::RandEquivalent((*__pyx_v_ifst1->_fst), (*__pyx_v_ifst2->_fst), __pyx_v_npath, __pyx_v_delta, __pyx_v_seed, (*__pyx_v_opts)); + goto __pyx_L0; + + /* "pywrapfst.pyx":3740 + * + * + * cpdef bool randequivalent(_Fst ifst1, # <<<<<<<<<<<<<< + * _Fst ifst2, + * int32 npath=1, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst.randequivalent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_43randequivalent(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_42randequivalent[] = "\n randequivalent(ifst1, ifst2, npath=1, delta=0.0009765625, seed=0,\n select=\"uniform\", max_length=2147483647)\n\n Are two acceptors stochastically equivalent?\n\n This operation tests whether two FSTs are equivalent by randomly generating\n paths alternatively in each of the two FSTs. For each randomly generated path,\n the algorithm computes for each of the two FSTs the sum of the weights of all\n the successful paths sharing the same input and output labels as the randomly\n generated path and checks that these two values are within `delta`.\n\n Args:\n ifst1: The first input FST.\n ifst2: The second input FST.\n npath: The number of random paths to generate.\n delta: Comparison/quantization delta.\n seed: An optional seed value for random path generation; if zero, the\n current time and process ID is used.\n select: A string matching a known random arc selection type; one of:\n \"uniform\", \"log_prob\", \"fast_log_prob\".\n max_length: The maximum length of each random path.\n\n Returns:\n True if the two transducers satisfy the above condition, else False.\n\n See also: `equal`, `equivalent`, `isomorphic`, `randgen`.\n "; +static PyObject *__pyx_pw_9pywrapfst_43randequivalent(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1 = 0; + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2 = 0; + __pyx_t_10basictypes_int32 __pyx_v_npath; + float __pyx_v_delta; + time_t __pyx_v_seed; + PyObject *__pyx_v_select = 0; + __pyx_t_10basictypes_int32 __pyx_v_max_length; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("randequivalent (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst1,&__pyx_n_s_ifst2,&__pyx_n_s_npath,&__pyx_n_s_delta,&__pyx_n_s_seed,&__pyx_n_s_select,&__pyx_n_s_max_length,0}; + PyObject* values[7] = {0,0,0,0,0,0,0}; + values[5] = ((PyObject *)__pyx_n_b_uniform); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst1)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst2)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("randequivalent", 0, 2, 7, 1); __PYX_ERR(0, 3740, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_npath); + if (value) { values[2] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_seed); + if (value) { values[4] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_select); + if (value) { values[5] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_max_length); + if (value) { values[6] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "randequivalent") < 0)) __PYX_ERR(0, 3740, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ifst1 = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]); + __pyx_v_ifst2 = ((struct __pyx_obj_9pywrapfst__Fst *)values[1]); + if (values[2]) { + __pyx_v_npath = __Pyx_PyInt_As_int32_t(values[2]); if (unlikely((__pyx_v_npath == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3742, __pyx_L3_error) + } else { + __pyx_v_npath = ((__pyx_t_10basictypes_int32)1); + } + if (values[3]) { + __pyx_v_delta = __pyx_PyFloat_AsFloat(values[3]); if (unlikely((__pyx_v_delta == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3743, __pyx_L3_error) + } else { + __pyx_v_delta = __pyx_k__79; + } + if (values[4]) { + __pyx_v_seed = __Pyx_PyInt_As_time_t(values[4]); if (unlikely((__pyx_v_seed == ((time_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3744, __pyx_L3_error) + } else { + __pyx_v_seed = ((time_t)0); + } + __pyx_v_select = values[5]; + if (values[6]) { + __pyx_v_max_length = __Pyx_PyInt_As_int32_t(values[6]); if (unlikely((__pyx_v_max_length == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3746, __pyx_L3_error) + } else { + __pyx_v_max_length = __pyx_k__80; + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("randequivalent", 0, 2, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3740, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.randequivalent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst1), __pyx_ptype_9pywrapfst__Fst, 1, "ifst1", 0))) __PYX_ERR(0, 3740, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst2), __pyx_ptype_9pywrapfst__Fst, 1, "ifst2", 0))) __PYX_ERR(0, 3741, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_42randequivalent(__pyx_self, __pyx_v_ifst1, __pyx_v_ifst2, __pyx_v_npath, __pyx_v_delta, __pyx_v_seed, __pyx_v_select, __pyx_v_max_length); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_42randequivalent(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, __pyx_t_10basictypes_int32 __pyx_v_npath, float __pyx_v_delta, time_t __pyx_v_seed, PyObject *__pyx_v_select, __pyx_t_10basictypes_int32 __pyx_v_max_length) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + bool __pyx_t_1; + struct __pyx_opt_args_9pywrapfst_randequivalent __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("randequivalent", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 5; + __pyx_t_2.npath = __pyx_v_npath; + __pyx_t_2.delta = __pyx_v_delta; + __pyx_t_2.seed = __pyx_v_seed; + __pyx_t_2.select = __pyx_v_select; + __pyx_t_2.max_length = __pyx_v_max_length; + __pyx_t_1 = __pyx_f_9pywrapfst_randequivalent(__pyx_v_ifst1, __pyx_v_ifst2, 0, &__pyx_t_2); if (unlikely(__pyx_t_1 == ((bool)-1) && PyErr_Occurred())) __PYX_ERR(0, 3740, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3740, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pywrapfst.randequivalent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3786 + * + * + * cpdef _MutableFst randgen(_Fst ifst, # <<<<<<<<<<<<<< + * int32 npath=1, + * time_t seed=0, + */ + +static PyObject *__pyx_pw_9pywrapfst_45randgen(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_randgen(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_randgen *__pyx_optional_args) { + __pyx_t_10basictypes_int32 __pyx_v_npath = ((__pyx_t_10basictypes_int32)1); + time_t __pyx_v_seed = ((time_t)0); + PyObject *__pyx_v_select = ((PyObject *)__pyx_n_b_uniform); + __pyx_t_10basictypes_int32 __pyx_v_max_length = __pyx_k__81; + + /* "pywrapfst.pyx":3791 + * select=b"uniform", + * int32 max_length=INT32_MAX, + * bool weighted=False, # <<<<<<<<<<<<<< + * bool remove_total_weight=False): + * """ + */ + bool __pyx_v_weighted = ((bool)0); + + /* "pywrapfst.pyx":3792 + * int32 max_length=INT32_MAX, + * bool weighted=False, + * bool remove_total_weight=False): # <<<<<<<<<<<<<< + * """ + * randgen(ifst, npath=1, seed=0, select="uniform", max_length=2147483647, + */ + bool __pyx_v_remove_total_weight = ((bool)0); + enum fst::script::RandArcSelection __pyx_v_ras; + std::unique_ptr > __pyx_v_opts; + std::unique_ptr __pyx_v_tfst; + struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + std::string __pyx_t_1; + enum fst::script::RandArcSelection __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("randgen", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_npath = __pyx_optional_args->npath; + if (__pyx_optional_args->__pyx_n > 1) { + __pyx_v_seed = __pyx_optional_args->seed; + if (__pyx_optional_args->__pyx_n > 2) { + __pyx_v_select = __pyx_optional_args->select; + if (__pyx_optional_args->__pyx_n > 3) { + __pyx_v_max_length = __pyx_optional_args->max_length; + if (__pyx_optional_args->__pyx_n > 4) { + __pyx_v_weighted = __pyx_optional_args->weighted; + if (__pyx_optional_args->__pyx_n > 5) { + __pyx_v_remove_total_weight = __pyx_optional_args->remove_total_weight; + } + } + } + } + } + } + } + + /* "pywrapfst.pyx":3824 + * See also: `randequivalent`. + * """ + * cdef fst.RandArcSelection ras = _get_rand_arc_selection(tostring(select)) # <<<<<<<<<<<<<< + * cdef unique_ptr[fst.RandGenOptions[fst.RandArcSelection]] opts + * opts.reset(new fst.RandGenOptions[fst.RandArcSelection](ras, max_length, + */ + __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_select, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3824, __pyx_L1_error) + __pyx_t_2 = __pyx_f_9pywrapfst__get_rand_arc_selection(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3824, __pyx_L1_error) + __pyx_v_ras = __pyx_t_2; + + /* "pywrapfst.pyx":3826 + * cdef fst.RandArcSelection ras = _get_rand_arc_selection(tostring(select)) + * cdef unique_ptr[fst.RandGenOptions[fst.RandArcSelection]] opts + * opts.reset(new fst.RandGenOptions[fst.RandArcSelection](ras, max_length, # <<<<<<<<<<<<<< + * npath, weighted, + * remove_total_weight)) + */ + __pyx_v_opts.reset(new fst::RandGenOptions (__pyx_v_ras, __pyx_v_max_length, __pyx_v_npath, __pyx_v_weighted, __pyx_v_remove_total_weight)); + + /* "pywrapfst.pyx":3830 + * remove_total_weight)) + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) # <<<<<<<<<<<<<< + * if seed == 0: + * seed = time(NULL) + getpid() + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "arc_type"); + __PYX_ERR(0, 3830, __pyx_L1_error) + } + __pyx_v_tfst.reset(new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->arc_type(__pyx_v_ifst, 0))); + + /* "pywrapfst.pyx":3831 + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + * if seed == 0: # <<<<<<<<<<<<<< + * seed = time(NULL) + getpid() + * fst.RandGen(deref(ifst._fst), tfst.get(), seed, deref(opts)) + */ + __pyx_t_3 = ((__pyx_v_seed == 0) != 0); + if (__pyx_t_3) { + + /* "pywrapfst.pyx":3832 + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + * if seed == 0: + * seed = time(NULL) + getpid() # <<<<<<<<<<<<<< + * fst.RandGen(deref(ifst._fst), tfst.get(), seed, deref(opts)) + * return _init_MutableFst(tfst.release()) + */ + __pyx_v_seed = (time(NULL) + getpid()); + + /* "pywrapfst.pyx":3831 + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + * if seed == 0: # <<<<<<<<<<<<<< + * seed = time(NULL) + getpid() + * fst.RandGen(deref(ifst._fst), tfst.get(), seed, deref(opts)) + */ + } + + /* "pywrapfst.pyx":3833 + * if seed == 0: + * seed = time(NULL) + getpid() + * fst.RandGen(deref(ifst._fst), tfst.get(), seed, deref(opts)) # <<<<<<<<<<<<<< + * return _init_MutableFst(tfst.release()) + * + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3833, __pyx_L1_error) + } + fst::script::RandGen((*__pyx_v_ifst->_fst), __pyx_v_tfst.get(), __pyx_v_seed, (*__pyx_v_opts)); + + /* "pywrapfst.pyx":3834 + * seed = time(NULL) + getpid() + * fst.RandGen(deref(ifst._fst), tfst.get(), seed, deref(opts)) + * return _init_MutableFst(tfst.release()) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_4 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst.release())); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3834, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = ((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_t_4); + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":3786 + * + * + * cpdef _MutableFst randgen(_Fst ifst, # <<<<<<<<<<<<<< + * int32 npath=1, + * time_t seed=0, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pywrapfst.randgen", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_45randgen(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_44randgen[] = "\n randgen(ifst, npath=1, seed=0, select=\"uniform\", max_length=2147483647,\n weight=False, remove_total_weight=False)\n\n Randomly generate successful paths in an FST.\n\n This operation randomly generates a set of successful paths in the input FST.\n This relies on a mechanism for selecting arcs, specified using the `select`\n argument. The default selector, \"uniform\", randomly selects a transition\n using a uniform distribution. The \"log_prob\" selector randomly selects a\n transition w.r.t. the weights treated as negative log probabilities after\n normalizing for the total weight leaving the state. In all cases, finality is\n treated as a transition to a super-final state.\n\n Args:\n ifst: The input FST.\n npath: The number of random paths to generate.\n seed: An optional seed value for random path generation; if zero, the\n current time and process ID is used.\n select: A string matching a known random arc selection type; one of:\n \"uniform\", \"log_prob\", \"fast_log_prob\".\n max_length: The maximum length of each random path.\n weighted: Should the output be weighted by path count?\n remove_total_weight: Should the total weight be removed (ignored when\n `weighted` is False)?\n\n Returns:\n An FST containing one or more random paths.\n\n See also: `randequivalent`.\n "; +static PyObject *__pyx_pw_9pywrapfst_45randgen(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0; + __pyx_t_10basictypes_int32 __pyx_v_npath; + time_t __pyx_v_seed; + PyObject *__pyx_v_select = 0; + __pyx_t_10basictypes_int32 __pyx_v_max_length; + bool __pyx_v_weighted; + bool __pyx_v_remove_total_weight; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("randgen (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_npath,&__pyx_n_s_seed,&__pyx_n_s_select,&__pyx_n_s_max_length,&__pyx_n_s_weighted,&__pyx_n_s_remove_total_weight,0}; + PyObject* values[7] = {0,0,0,0,0,0,0}; + values[3] = ((PyObject *)__pyx_n_b_uniform); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_npath); + if (value) { values[1] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_seed); + if (value) { values[2] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_select); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_max_length); + if (value) { values[4] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weighted); + if (value) { values[5] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_remove_total_weight); + if (value) { values[6] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "randgen") < 0)) __PYX_ERR(0, 3786, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ifst = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]); + if (values[1]) { + __pyx_v_npath = __Pyx_PyInt_As_int32_t(values[1]); if (unlikely((__pyx_v_npath == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3787, __pyx_L3_error) + } else { + __pyx_v_npath = ((__pyx_t_10basictypes_int32)1); + } + if (values[2]) { + __pyx_v_seed = __Pyx_PyInt_As_time_t(values[2]); if (unlikely((__pyx_v_seed == ((time_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3788, __pyx_L3_error) + } else { + __pyx_v_seed = ((time_t)0); + } + __pyx_v_select = values[3]; + if (values[4]) { + __pyx_v_max_length = __Pyx_PyInt_As_int32_t(values[4]); if (unlikely((__pyx_v_max_length == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3790, __pyx_L3_error) + } else { + __pyx_v_max_length = __pyx_k__81; + } + if (values[5]) { + __pyx_v_weighted = __Pyx_PyObject_IsTrue(values[5]); if (unlikely((__pyx_v_weighted == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3791, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":3791 + * select=b"uniform", + * int32 max_length=INT32_MAX, + * bool weighted=False, # <<<<<<<<<<<<<< + * bool remove_total_weight=False): + * """ + */ + __pyx_v_weighted = ((bool)0); + } + if (values[6]) { + __pyx_v_remove_total_weight = __Pyx_PyObject_IsTrue(values[6]); if (unlikely((__pyx_v_remove_total_weight == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3792, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":3792 + * int32 max_length=INT32_MAX, + * bool weighted=False, + * bool remove_total_weight=False): # <<<<<<<<<<<<<< + * """ + * randgen(ifst, npath=1, seed=0, select="uniform", max_length=2147483647, + */ + __pyx_v_remove_total_weight = ((bool)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("randgen", 0, 1, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3786, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.randgen", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst), __pyx_ptype_9pywrapfst__Fst, 1, "ifst", 0))) __PYX_ERR(0, 3786, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_44randgen(__pyx_self, __pyx_v_ifst, __pyx_v_npath, __pyx_v_seed, __pyx_v_select, __pyx_v_max_length, __pyx_v_weighted, __pyx_v_remove_total_weight); + + /* "pywrapfst.pyx":3786 + * + * + * cpdef _MutableFst randgen(_Fst ifst, # <<<<<<<<<<<<<< + * int32 npath=1, + * time_t seed=0, + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_44randgen(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, __pyx_t_10basictypes_int32 __pyx_v_npath, time_t __pyx_v_seed, PyObject *__pyx_v_select, __pyx_t_10basictypes_int32 __pyx_v_max_length, bool __pyx_v_weighted, bool __pyx_v_remove_total_weight) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + struct __pyx_opt_args_9pywrapfst_randgen __pyx_t_2; + __Pyx_RefNannySetupContext("randgen", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 6; + __pyx_t_2.npath = __pyx_v_npath; + __pyx_t_2.seed = __pyx_v_seed; + __pyx_t_2.select = __pyx_v_select; + __pyx_t_2.max_length = __pyx_v_max_length; + __pyx_t_2.remove_total_weight = __pyx_v_weighted; + __pyx_t_2.weighted = __pyx_v_remove_total_weight; + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_randgen(__pyx_v_ifst, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3786, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.randgen", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3837 + * + * + * cpdef _MutableFst replace(pairs, # <<<<<<<<<<<<<< + * call_arc_labeling=b"input", + * return_arc_labeling=b"neither", + */ + +static PyObject *__pyx_pw_9pywrapfst_47replace(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_replace(PyObject *__pyx_v_pairs, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_replace *__pyx_optional_args) { + PyObject *__pyx_v_call_arc_labeling = ((PyObject *)__pyx_n_b_input); + PyObject *__pyx_v_return_arc_labeling = ((PyObject *)__pyx_n_b_neither); + + /* "pywrapfst.pyx":3840 + * call_arc_labeling=b"input", + * return_arc_labeling=b"neither", + * bool epsilon_on_replace=False, # <<<<<<<<<<<<<< + * int64 return_label=0): + * """ + */ + bool __pyx_v_epsilon_on_replace = ((bool)0); + __pyx_t_10basictypes_int64 __pyx_v_return_label = ((__pyx_t_10basictypes_int64)0); + std::vector<__pyx_t_3fst_LabelFstClassPair> __pyx_v__pairs; + __pyx_t_10basictypes_int64 __pyx_v_root_label; + __pyx_t_10basictypes_int64 __pyx_v_label; + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0; + PyObject *__pyx_v_it = NULL; + std::unique_ptr __pyx_v_tfst; + enum fst::ReplaceLabelType __pyx_v_cal; + enum fst::ReplaceLabelType __pyx_v_ral; + std::unique_ptr __pyx_v_opts; + struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *(*__pyx_t_5)(PyObject *); + __pyx_t_10basictypes_int64 __pyx_t_6; + __pyx_t_3fst_LabelFstClassPair __pyx_t_7; + Py_ssize_t __pyx_t_8; + PyObject *(*__pyx_t_9)(PyObject *); + PyObject *__pyx_t_10 = NULL; + std::string __pyx_t_11; + enum fst::ReplaceLabelType __pyx_t_12; + __Pyx_RefNannySetupContext("replace", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_call_arc_labeling = __pyx_optional_args->call_arc_labeling; + if (__pyx_optional_args->__pyx_n > 1) { + __pyx_v_return_arc_labeling = __pyx_optional_args->return_arc_labeling; + if (__pyx_optional_args->__pyx_n > 2) { + __pyx_v_epsilon_on_replace = __pyx_optional_args->epsilon_on_replace; + if (__pyx_optional_args->__pyx_n > 3) { + __pyx_v_return_label = __pyx_optional_args->return_label; + } + } + } + } + } + + /* "pywrapfst.pyx":3882 + * cdef int64 label + * cdef _Fst ifst + * it = iter(pairs) # <<<<<<<<<<<<<< + * (root_label, ifst) = next(it) + * _pairs.push_back(fst.LabelFstClassPair(root_label, ifst._fst.get())) + */ + __pyx_t_1 = PyObject_GetIter(__pyx_v_pairs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3882, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_it = __pyx_t_1; + __pyx_t_1 = 0; + + /* "pywrapfst.pyx":3883 + * cdef _Fst ifst + * it = iter(pairs) + * (root_label, ifst) = next(it) # <<<<<<<<<<<<<< + * _pairs.push_back(fst.LabelFstClassPair(root_label, ifst._fst.get())) + * cdef unique_ptr[fst.VectorFstClass] tfst + */ + __pyx_t_1 = __Pyx_PyIter_Next(__pyx_v_it); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3883, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { + PyObject* sequence = __pyx_t_1; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 3883, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_2 = PyList_GET_ITEM(sequence, 0); + __pyx_t_3 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + #else + __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3883, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3883, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3883, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = Py_TYPE(__pyx_t_4)->tp_iternext; + index = 0; __pyx_t_2 = __pyx_t_5(__pyx_t_4); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + index = 1; __pyx_t_3 = __pyx_t_5(__pyx_t_4); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed; + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_4), 2) < 0) __PYX_ERR(0, 3883, __pyx_L1_error) + __pyx_t_5 = NULL; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L4_unpacking_done; + __pyx_L3_unpacking_failed:; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 3883, __pyx_L1_error) + __pyx_L4_unpacking_done:; + } + __pyx_t_6 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_6 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3883, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_9pywrapfst__Fst))))) __PYX_ERR(0, 3883, __pyx_L1_error) + __pyx_v_root_label = __pyx_t_6; + __pyx_v_ifst = ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "pywrapfst.pyx":3884 + * it = iter(pairs) + * (root_label, ifst) = next(it) + * _pairs.push_back(fst.LabelFstClassPair(root_label, ifst._fst.get())) # <<<<<<<<<<<<<< + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3884, __pyx_L1_error) + } + try { + __pyx_t_7 = __pyx_t_3fst_LabelFstClassPair(__pyx_v_root_label, __pyx_v_ifst->_fst.get()); + } catch(...) { + __Pyx_CppExn2PyErr(); + __PYX_ERR(0, 3884, __pyx_L1_error) + } + try { + __pyx_v__pairs.push_back(__pyx_t_7); + } catch(...) { + __Pyx_CppExn2PyErr(); + __PYX_ERR(0, 3884, __pyx_L1_error) + } + + /* "pywrapfst.pyx":3886 + * _pairs.push_back(fst.LabelFstClassPair(root_label, ifst._fst.get())) + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) # <<<<<<<<<<<<<< + * for (label, ifst) in it: + * _pairs.push_back(fst.LabelFstClassPair(label, ifst._fst.get())) + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "arc_type"); + __PYX_ERR(0, 3886, __pyx_L1_error) + } + __pyx_v_tfst.reset(new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->arc_type(__pyx_v_ifst, 0))); + + /* "pywrapfst.pyx":3887 + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + * for (label, ifst) in it: # <<<<<<<<<<<<<< + * _pairs.push_back(fst.LabelFstClassPair(label, ifst._fst.get())) + * cdef fst.ReplaceLabelType cal = _get_replace_label_type( + */ + if (likely(PyList_CheckExact(__pyx_v_it)) || PyTuple_CheckExact(__pyx_v_it)) { + __pyx_t_1 = __pyx_v_it; __Pyx_INCREF(__pyx_t_1); __pyx_t_8 = 0; + __pyx_t_9 = NULL; + } else { + __pyx_t_8 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_it); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3887, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3887, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_9)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + if (__pyx_t_8 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_3); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 3887, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3887, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } else { + if (__pyx_t_8 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_3); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 3887, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3887, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } + } else { + __pyx_t_3 = __pyx_t_9(__pyx_t_1); + if (unlikely(!__pyx_t_3)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 3887, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_3); + } + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + PyObject* sequence = __pyx_t_3; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 3887, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_2 = PyList_GET_ITEM(sequence, 0); + __pyx_t_4 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3887, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3887, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_10 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3887, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = Py_TYPE(__pyx_t_10)->tp_iternext; + index = 0; __pyx_t_2 = __pyx_t_5(__pyx_t_10); if (unlikely(!__pyx_t_2)) goto __pyx_L7_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + index = 1; __pyx_t_4 = __pyx_t_5(__pyx_t_10); if (unlikely(!__pyx_t_4)) goto __pyx_L7_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_10), 2) < 0) __PYX_ERR(0, 3887, __pyx_L1_error) + __pyx_t_5 = NULL; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + goto __pyx_L8_unpacking_done; + __pyx_L7_unpacking_failed:; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_5 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 3887, __pyx_L1_error) + __pyx_L8_unpacking_done:; + } + __pyx_t_6 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_6 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3887, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_9pywrapfst__Fst))))) __PYX_ERR(0, 3887, __pyx_L1_error) + __pyx_v_label = __pyx_t_6; + __Pyx_DECREF_SET(__pyx_v_ifst, ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "pywrapfst.pyx":3888 + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + * for (label, ifst) in it: + * _pairs.push_back(fst.LabelFstClassPair(label, ifst._fst.get())) # <<<<<<<<<<<<<< + * cdef fst.ReplaceLabelType cal = _get_replace_label_type( + * tostring(call_arc_labeling), epsilon_on_replace) + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3888, __pyx_L1_error) + } + try { + __pyx_t_7 = __pyx_t_3fst_LabelFstClassPair(__pyx_v_label, __pyx_v_ifst->_fst.get()); + } catch(...) { + __Pyx_CppExn2PyErr(); + __PYX_ERR(0, 3888, __pyx_L1_error) + } + try { + __pyx_v__pairs.push_back(__pyx_t_7); + } catch(...) { + __Pyx_CppExn2PyErr(); + __PYX_ERR(0, 3888, __pyx_L1_error) + } + + /* "pywrapfst.pyx":3887 + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + * for (label, ifst) in it: # <<<<<<<<<<<<<< + * _pairs.push_back(fst.LabelFstClassPair(label, ifst._fst.get())) + * cdef fst.ReplaceLabelType cal = _get_replace_label_type( + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":3890 + * _pairs.push_back(fst.LabelFstClassPair(label, ifst._fst.get())) + * cdef fst.ReplaceLabelType cal = _get_replace_label_type( + * tostring(call_arc_labeling), epsilon_on_replace) # <<<<<<<<<<<<<< + * cdef fst.ReplaceLabelType ral = _get_replace_label_type( + * tostring(return_arc_labeling), epsilon_on_replace) + */ + __pyx_t_11 = __pyx_f_9pywrapfst_tostring(__pyx_v_call_arc_labeling, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3890, __pyx_L1_error) + + /* "pywrapfst.pyx":3889 + * for (label, ifst) in it: + * _pairs.push_back(fst.LabelFstClassPair(label, ifst._fst.get())) + * cdef fst.ReplaceLabelType cal = _get_replace_label_type( # <<<<<<<<<<<<<< + * tostring(call_arc_labeling), epsilon_on_replace) + * cdef fst.ReplaceLabelType ral = _get_replace_label_type( + */ + __pyx_t_12 = __pyx_f_9pywrapfst__get_replace_label_type(__pyx_t_11, __pyx_v_epsilon_on_replace); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3889, __pyx_L1_error) + __pyx_v_cal = __pyx_t_12; + + /* "pywrapfst.pyx":3892 + * tostring(call_arc_labeling), epsilon_on_replace) + * cdef fst.ReplaceLabelType ral = _get_replace_label_type( + * tostring(return_arc_labeling), epsilon_on_replace) # <<<<<<<<<<<<<< + * cdef unique_ptr[fst.ReplaceOptions] opts + * opts.reset(new fst.ReplaceOptions(root_label, cal, ral, return_label)) + */ + __pyx_t_11 = __pyx_f_9pywrapfst_tostring(__pyx_v_return_arc_labeling, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3892, __pyx_L1_error) + + /* "pywrapfst.pyx":3891 + * cdef fst.ReplaceLabelType cal = _get_replace_label_type( + * tostring(call_arc_labeling), epsilon_on_replace) + * cdef fst.ReplaceLabelType ral = _get_replace_label_type( # <<<<<<<<<<<<<< + * tostring(return_arc_labeling), epsilon_on_replace) + * cdef unique_ptr[fst.ReplaceOptions] opts + */ + __pyx_t_12 = __pyx_f_9pywrapfst__get_replace_label_type(__pyx_t_11, __pyx_v_epsilon_on_replace); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3891, __pyx_L1_error) + __pyx_v_ral = __pyx_t_12; + + /* "pywrapfst.pyx":3894 + * tostring(return_arc_labeling), epsilon_on_replace) + * cdef unique_ptr[fst.ReplaceOptions] opts + * opts.reset(new fst.ReplaceOptions(root_label, cal, ral, return_label)) # <<<<<<<<<<<<<< + * fst.Replace(_pairs, tfst.get(), deref(opts)) + * return _init_MutableFst(tfst.release()) + */ + __pyx_v_opts.reset(new fst::script::ReplaceOptions(__pyx_v_root_label, __pyx_v_cal, __pyx_v_ral, __pyx_v_return_label)); + + /* "pywrapfst.pyx":3895 + * cdef unique_ptr[fst.ReplaceOptions] opts + * opts.reset(new fst.ReplaceOptions(root_label, cal, ral, return_label)) + * fst.Replace(_pairs, tfst.get(), deref(opts)) # <<<<<<<<<<<<<< + * return _init_MutableFst(tfst.release()) + * + */ + fst::script::Replace(__pyx_v__pairs, __pyx_v_tfst.get(), (*__pyx_v_opts)); + + /* "pywrapfst.pyx":3896 + * opts.reset(new fst.ReplaceOptions(root_label, cal, ral, return_label)) + * fst.Replace(_pairs, tfst.get(), deref(opts)) + * return _init_MutableFst(tfst.release()) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst.release())); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3896, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = ((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":3837 + * + * + * cpdef _MutableFst replace(pairs, # <<<<<<<<<<<<<< + * call_arc_labeling=b"input", + * return_arc_labeling=b"neither", + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("pywrapfst.replace", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_ifst); + __Pyx_XDECREF(__pyx_v_it); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_47replace(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_46replace[] = "\n replace(pairs, call_arc_labeling=\"input\", return_arc_labeling=\"neither\",\n epsilon_on_replace=False, return_label=0)\n\n Recursively replaces arcs in the FST with other FST(s).\n\n This operation performs the dynamic replacement of arcs in one FST with\n another FST, allowing the definition of FSTs analogous to RTNs. It takes as\n input a set of pairs of a set of pairs formed by a non-terminal label and\n its corresponding FST, and a label identifying the root FST in that set.\n The resulting FST is obtained by taking the root FST and recursively replacing\n each arc having a nonterminal as output label by its corresponding FST. More\n precisely, an arc from state s to state d with (nonterminal) output label n in\n this FST is replaced by redirecting this \"call\" arc to the initial state of a\n copy F of the FST for n, and adding \"return\" arcs from each final state of F\n to d. Optional arguments control how the call and return arcs are labeled; by\n default, the only non-epsilon label is placed on the call arc.\n\n Args:\n\n pairs: An iterable of (nonterminal label, FST) pairs, where the former is an\n unsigned integer and the latter is an Fst instance.\n call_arc_labeling: A string indicating which call arc labels should be\n non-epsilon. One of: \"input\" (default), \"output\", \"both\", \"neither\".\n This value is set to \"neither\" if epsilon_on_replace is True.\n return_arc_labeling: A string indicating which return arc labels should be\n non-epsilon. One of: \"input\", \"output\", \"both\", \"neither\" (default).\n This value is set to \"neither\" if epsilon_on_replace is True.\n epsilon_on_replace: Should call and return arcs be epsilon arcs? If True,\n this effectively overrides call_arc_labeling and return_arc_labeling,\n setting both to \"neither\".\n return_label: The integer label for return arcs.\n\n Returns:\n An FST resulting from expanding the input"" RTN.\n "; +static PyObject *__pyx_pw_9pywrapfst_47replace(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_pairs = 0; + PyObject *__pyx_v_call_arc_labeling = 0; + PyObject *__pyx_v_return_arc_labeling = 0; + bool __pyx_v_epsilon_on_replace; + __pyx_t_10basictypes_int64 __pyx_v_return_label; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("replace (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pairs,&__pyx_n_s_call_arc_labeling,&__pyx_n_s_return_arc_labeling,&__pyx_n_s_epsilon_on_replace,&__pyx_n_s_return_label,0}; + PyObject* values[5] = {0,0,0,0,0}; + values[1] = ((PyObject *)__pyx_n_b_input); + values[2] = ((PyObject *)__pyx_n_b_neither); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pairs)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_call_arc_labeling); + if (value) { values[1] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_return_arc_labeling); + if (value) { values[2] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_epsilon_on_replace); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_return_label); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "replace") < 0)) __PYX_ERR(0, 3837, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_pairs = values[0]; + __pyx_v_call_arc_labeling = values[1]; + __pyx_v_return_arc_labeling = values[2]; + if (values[3]) { + __pyx_v_epsilon_on_replace = __Pyx_PyObject_IsTrue(values[3]); if (unlikely((__pyx_v_epsilon_on_replace == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3840, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":3840 + * call_arc_labeling=b"input", + * return_arc_labeling=b"neither", + * bool epsilon_on_replace=False, # <<<<<<<<<<<<<< + * int64 return_label=0): + * """ + */ + __pyx_v_epsilon_on_replace = ((bool)0); + } + if (values[4]) { + __pyx_v_return_label = __Pyx_PyInt_As_int64_t(values[4]); if (unlikely((__pyx_v_return_label == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3841, __pyx_L3_error) + } else { + __pyx_v_return_label = ((__pyx_t_10basictypes_int64)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("replace", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3837, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.replace", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_46replace(__pyx_self, __pyx_v_pairs, __pyx_v_call_arc_labeling, __pyx_v_return_arc_labeling, __pyx_v_epsilon_on_replace, __pyx_v_return_label); + + /* "pywrapfst.pyx":3837 + * + * + * cpdef _MutableFst replace(pairs, # <<<<<<<<<<<<<< + * call_arc_labeling=b"input", + * return_arc_labeling=b"neither", + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_46replace(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_pairs, PyObject *__pyx_v_call_arc_labeling, PyObject *__pyx_v_return_arc_labeling, bool __pyx_v_epsilon_on_replace, __pyx_t_10basictypes_int64 __pyx_v_return_label) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + struct __pyx_opt_args_9pywrapfst_replace __pyx_t_2; + __Pyx_RefNannySetupContext("replace", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 4; + __pyx_t_2.call_arc_labeling = __pyx_v_call_arc_labeling; + __pyx_t_2.return_arc_labeling = __pyx_v_return_arc_labeling; + __pyx_t_2.epsilon_on_replace = __pyx_v_epsilon_on_replace; + __pyx_t_2.return_label = __pyx_v_return_label; + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_replace(__pyx_v_pairs, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3837, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.replace", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3899 + * + * + * cpdef _MutableFst reverse(_Fst ifst, bool require_superinitial=True): # <<<<<<<<<<<<<< + * """ + * reverse(ifst, require_superinitial=True) + */ + +static PyObject *__pyx_pw_9pywrapfst_49reverse(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_reverse(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_reverse *__pyx_optional_args) { + bool __pyx_v_require_superinitial = ((bool)1); + std::unique_ptr __pyx_v_tfst; + struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("reverse", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_require_superinitial = __pyx_optional_args->require_superinitial; + } + } + + /* "pywrapfst.pyx":3919 + * """ + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) # <<<<<<<<<<<<<< + * fst.Reverse(deref(ifst._fst), tfst.get(), require_superinitial) + * return _init_MutableFst(tfst.release()) + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "arc_type"); + __PYX_ERR(0, 3919, __pyx_L1_error) + } + __pyx_v_tfst.reset(new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->arc_type(__pyx_v_ifst, 0))); + + /* "pywrapfst.pyx":3920 + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + * fst.Reverse(deref(ifst._fst), tfst.get(), require_superinitial) # <<<<<<<<<<<<<< + * return _init_MutableFst(tfst.release()) + * + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3920, __pyx_L1_error) + } + fst::script::Reverse((*__pyx_v_ifst->_fst), __pyx_v_tfst.get(), __pyx_v_require_superinitial); + + /* "pywrapfst.pyx":3921 + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + * fst.Reverse(deref(ifst._fst), tfst.get(), require_superinitial) + * return _init_MutableFst(tfst.release()) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst.release())); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3921, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = ((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":3899 + * + * + * cpdef _MutableFst reverse(_Fst ifst, bool require_superinitial=True): # <<<<<<<<<<<<<< + * """ + * reverse(ifst, require_superinitial=True) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.reverse", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_49reverse(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_48reverse[] = "\n reverse(ifst, require_superinitial=True)\n\n Constructively reverses an FST's transduction.\n\n This operation reverses an FST. If A transduces string x to y with weight a,\n then the reverse of A transduces the reverse of x to the reverse of y with\n weight a.Reverse(). (Typically, a = a.Reverse() and Arc = RevArc, e.g.,\n TropicalWeight and LogWeight.) In general, e.g., when the weights only form a\n left or right semiring, the output arc type must match the input arc type.\n\n Args:\n ifst: The input FST.\n require_superinitial: Should a superinitial state be created?\n\n Returns:\n A reversed FST.\n "; +static PyObject *__pyx_pw_9pywrapfst_49reverse(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0; + bool __pyx_v_require_superinitial; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("reverse (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_require_superinitial,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_require_superinitial); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "reverse") < 0)) __PYX_ERR(0, 3899, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ifst = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]); + if (values[1]) { + __pyx_v_require_superinitial = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_require_superinitial == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3899, __pyx_L3_error) + } else { + __pyx_v_require_superinitial = ((bool)1); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("reverse", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3899, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.reverse", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst), __pyx_ptype_9pywrapfst__Fst, 1, "ifst", 0))) __PYX_ERR(0, 3899, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_48reverse(__pyx_self, __pyx_v_ifst, __pyx_v_require_superinitial); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_48reverse(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, bool __pyx_v_require_superinitial) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + struct __pyx_opt_args_9pywrapfst_reverse __pyx_t_2; + __Pyx_RefNannySetupContext("reverse", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 1; + __pyx_t_2.require_superinitial = __pyx_v_require_superinitial; + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_reverse(__pyx_v_ifst, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3899, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.reverse", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3927 + * + * + * cdef vector[fst.WeightClass] *_shortestdistance(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kShortestDelta, + * int64 nstate=fst.kNoStateId, + */ + +static std::vector *__pyx_f_9pywrapfst__shortestdistance(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, struct __pyx_opt_args_9pywrapfst__shortestdistance *__pyx_optional_args) { + float __pyx_v_delta = __pyx_k__82; + __pyx_t_10basictypes_int64 __pyx_v_nstate = __pyx_k__83; + PyObject *__pyx_v_queue_type = ((PyObject *)__pyx_n_b_auto); + + /* "pywrapfst.pyx":3931 + * int64 nstate=fst.kNoStateId, + * queue_type=b"auto", + * bool reverse=False) except *: # <<<<<<<<<<<<<< + * cdef unique_ptr[vector[fst.WeightClass]] distance + * distance.reset(new vector[fst.WeightClass]()) + */ + bool __pyx_v_reverse = ((bool)0); + std::unique_ptr > __pyx_v_distance; + std::unique_ptr __pyx_v_opts; + std::vector *__pyx_r; + __Pyx_RefNannyDeclarations + std::vector *__pyx_t_1; + int __pyx_t_2; + std::string __pyx_t_3; + enum fst::QueueType __pyx_t_4; + __Pyx_RefNannySetupContext("_shortestdistance", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_delta = __pyx_optional_args->delta; + if (__pyx_optional_args->__pyx_n > 1) { + __pyx_v_nstate = __pyx_optional_args->nstate; + if (__pyx_optional_args->__pyx_n > 2) { + __pyx_v_queue_type = __pyx_optional_args->queue_type; + if (__pyx_optional_args->__pyx_n > 3) { + __pyx_v_reverse = __pyx_optional_args->reverse; + } + } + } + } + } + + /* "pywrapfst.pyx":3933 + * bool reverse=False) except *: + * cdef unique_ptr[vector[fst.WeightClass]] distance + * distance.reset(new vector[fst.WeightClass]()) # <<<<<<<<<<<<<< + * # For scoping reasons, these have to be declared here even though they may + * # not be used in all cases. + */ + try { + __pyx_t_1 = new std::vector (); + } catch(...) { + __Pyx_CppExn2PyErr(); + __PYX_ERR(0, 3933, __pyx_L1_error) + } + __pyx_v_distance.reset(__pyx_t_1); + + /* "pywrapfst.pyx":3937 + * # not be used in all cases. + * cdef unique_ptr[fst.ShortestDistanceOptions] opts + * if reverse: # <<<<<<<<<<<<<< + * # Only the simpler signature supports shortest distance to final states; + * # `nstate` and `queue_type` arguments are ignored. + */ + __pyx_t_2 = (__pyx_v_reverse != 0); + if (__pyx_t_2) { + + /* "pywrapfst.pyx":3940 + * # Only the simpler signature supports shortest distance to final states; + * # `nstate` and `queue_type` arguments are ignored. + * fst.ShortestDistance(deref(ifst._fst), distance.get(), True, delta) # <<<<<<<<<<<<<< + * else: + * opts.reset(new fst.ShortestDistanceOptions( + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3940, __pyx_L1_error) + } + fst::script::ShortestDistance((*__pyx_v_ifst->_fst), __pyx_v_distance.get(), 1, __pyx_v_delta); + + /* "pywrapfst.pyx":3937 + * # not be used in all cases. + * cdef unique_ptr[fst.ShortestDistanceOptions] opts + * if reverse: # <<<<<<<<<<<<<< + * # Only the simpler signature supports shortest distance to final states; + * # `nstate` and `queue_type` arguments are ignored. + */ + goto __pyx_L3; + } + + /* "pywrapfst.pyx":3942 + * fst.ShortestDistance(deref(ifst._fst), distance.get(), True, delta) + * else: + * opts.reset(new fst.ShortestDistanceOptions( # <<<<<<<<<<<<<< + * _get_queue_type(tostring(queue_type)), fst.ANY_ARC_FILTER, nstate, + * delta)) + */ + /*else*/ { + + /* "pywrapfst.pyx":3943 + * else: + * opts.reset(new fst.ShortestDistanceOptions( + * _get_queue_type(tostring(queue_type)), fst.ANY_ARC_FILTER, nstate, # <<<<<<<<<<<<<< + * delta)) + * fst.ShortestDistance(deref(ifst._fst), distance.get(), deref(opts)) + */ + __pyx_t_3 = __pyx_f_9pywrapfst_tostring(__pyx_v_queue_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3943, __pyx_L1_error) + __pyx_t_4 = __pyx_f_9pywrapfst__get_queue_type(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3943, __pyx_L1_error) + + /* "pywrapfst.pyx":3942 + * fst.ShortestDistance(deref(ifst._fst), distance.get(), True, delta) + * else: + * opts.reset(new fst.ShortestDistanceOptions( # <<<<<<<<<<<<<< + * _get_queue_type(tostring(queue_type)), fst.ANY_ARC_FILTER, nstate, + * delta)) + */ + __pyx_v_opts.reset(new fst::script::ShortestDistanceOptions(__pyx_t_4, fst::script::ANY_ARC_FILTER, __pyx_v_nstate, __pyx_v_delta)); + + /* "pywrapfst.pyx":3945 + * _get_queue_type(tostring(queue_type)), fst.ANY_ARC_FILTER, nstate, + * delta)) + * fst.ShortestDistance(deref(ifst._fst), distance.get(), deref(opts)) # <<<<<<<<<<<<<< + * return distance.release() + * + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 3945, __pyx_L1_error) + } + fst::script::ShortestDistance((*__pyx_v_ifst->_fst), __pyx_v_distance.get(), (*__pyx_v_opts)); + } + __pyx_L3:; + + /* "pywrapfst.pyx":3946 + * delta)) + * fst.ShortestDistance(deref(ifst._fst), distance.get(), deref(opts)) + * return distance.release() # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_distance.release(); + goto __pyx_L0; + + /* "pywrapfst.pyx":3927 + * + * + * cdef vector[fst.WeightClass] *_shortestdistance(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kShortestDelta, + * int64 nstate=fst.kNoStateId, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst._shortestdistance", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3949 + * + * + * def shortestdistance(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kShortestDelta, + * int64 nstate=fst.kNoStateId, + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_51shortestdistance(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_50shortestdistance[] = "\n shortestdistance(ifst, delta=1e-6, nstate=NO_STATE_ID,\n queue_type=\"auto\", reverse=False)\n\n Compute the shortest distance from the initial or final state.\n\n This operation computes the shortest distance from the initial state (when\n `reverse` is False) or from every state to the final state (when `reverse` is\n True). The shortest distance from p to q is the \\otimes-sum of the weights of\n all the paths between p and q. The weights must be right (if `reverse` is\n False) or left (if `reverse` is True) distributive, and k-closed (i.e., 1\n \\otimes x \\otimes x^2 \\otimes ... \\otimes x^{k + 1} = 1 \\otimes x \\otimes x^2\n \\otimes ... \\otimes x^k; e.g., TropicalWeight).\n\n Args:\n ifst: The input FST.\n delta: Comparison/quantization delta.\n nstate: State number threshold (ignored if `reverse` is True).\n queue_type: A string matching a known queue type; one of: \"auto\", \"fifo\",\n \"lifo\", \"shortest\", \"state\", \"top\" (ignored if `reverse` is True).\n reverse: Should the reverse distance (from each state to the final state)\n be computed?\n\n Returns:\n A list of Weight objects representing the shortest distance for each state.\n "; +static PyMethodDef __pyx_mdef_9pywrapfst_51shortestdistance = {"shortestdistance", (PyCFunction)__pyx_pw_9pywrapfst_51shortestdistance, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_50shortestdistance}; +static PyObject *__pyx_pw_9pywrapfst_51shortestdistance(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0; + float __pyx_v_delta; + __pyx_t_10basictypes_int64 __pyx_v_nstate; + PyObject *__pyx_v_queue_type = 0; + bool __pyx_v_reverse; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("shortestdistance (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_delta,&__pyx_n_s_nstate,&__pyx_n_s_queue_type,&__pyx_n_s_reverse,0}; + PyObject* values[5] = {0,0,0,0,0}; + values[3] = ((PyObject *)__pyx_n_b_auto); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta); + if (value) { values[1] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nstate); + if (value) { values[2] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_queue_type); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_reverse); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "shortestdistance") < 0)) __PYX_ERR(0, 3949, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ifst = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]); + if (values[1]) { + __pyx_v_delta = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_delta == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3950, __pyx_L3_error) + } else { + __pyx_v_delta = __pyx_k__84; + } + if (values[2]) { + __pyx_v_nstate = __Pyx_PyInt_As_int64_t(values[2]); if (unlikely((__pyx_v_nstate == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3951, __pyx_L3_error) + } else { + __pyx_v_nstate = __pyx_k__85; + } + __pyx_v_queue_type = values[3]; + if (values[4]) { + __pyx_v_reverse = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_reverse == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3953, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":3953 + * int64 nstate=fst.kNoStateId, + * queue_type=b"auto", + * bool reverse=False): # <<<<<<<<<<<<<< + * """ + * shortestdistance(ifst, delta=1e-6, nstate=NO_STATE_ID, + */ + __pyx_v_reverse = ((bool)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("shortestdistance", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3949, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.shortestdistance", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst), __pyx_ptype_9pywrapfst__Fst, 1, "ifst", 0))) __PYX_ERR(0, 3949, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_50shortestdistance(__pyx_self, __pyx_v_ifst, __pyx_v_delta, __pyx_v_nstate, __pyx_v_queue_type, __pyx_v_reverse); + + /* "pywrapfst.pyx":3949 + * + * + * def shortestdistance(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kShortestDelta, + * int64 nstate=fst.kNoStateId, + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_50shortestdistance(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, __pyx_t_10basictypes_int64 __pyx_v_nstate, PyObject *__pyx_v_queue_type, bool __pyx_v_reverse) { + std::unique_ptr > __pyx_v_distance; + std::string __pyx_v_weight_type; + fst::script::WeightClass __pyx_v_weight; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + std::vector *__pyx_t_1; + struct __pyx_opt_args_9pywrapfst__shortestdistance __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + std::vector ::iterator __pyx_t_4; + fst::script::WeightClass __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("shortestdistance", 0); + + /* "pywrapfst.pyx":3981 + * """ + * cdef unique_ptr[vector[fst.WeightClass]] distance + * distance.reset(_shortestdistance(ifst, delta, nstate, queue_type, reverse)) # <<<<<<<<<<<<<< + * cdef string weight_type = ifst.weight_type() + * return [Weight(weight_type, weight.ToString()) for weight in deref(distance)] + */ + __pyx_t_2.__pyx_n = 4; + __pyx_t_2.delta = __pyx_v_delta; + __pyx_t_2.nstate = __pyx_v_nstate; + __pyx_t_2.queue_type = __pyx_v_queue_type; + __pyx_t_2.reverse = __pyx_v_reverse; + __pyx_t_1 = __pyx_f_9pywrapfst__shortestdistance(__pyx_v_ifst, &__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3981, __pyx_L1_error) + __pyx_v_distance.reset(__pyx_t_1); + + /* "pywrapfst.pyx":3982 + * cdef unique_ptr[vector[fst.WeightClass]] distance + * distance.reset(_shortestdistance(ifst, delta, nstate, queue_type, reverse)) + * cdef string weight_type = ifst.weight_type() # <<<<<<<<<<<<<< + * return [Weight(weight_type, weight.ToString()) for weight in deref(distance)] + * + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "weight_type"); + __PYX_ERR(0, 3982, __pyx_L1_error) + } + __pyx_v_weight_type = ((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->weight_type(__pyx_v_ifst, 0); + + /* "pywrapfst.pyx":3983 + * distance.reset(_shortestdistance(ifst, delta, nstate, queue_type, reverse)) + * cdef string weight_type = ifst.weight_type() + * return [Weight(weight_type, weight.ToString()) for weight in deref(distance)] # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3983, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = &(*__pyx_v_distance); + __pyx_t_4 = __pyx_t_1->begin(); + for (;;) { + if (!(__pyx_t_4 != __pyx_t_1->end())) break; + __pyx_t_5 = *__pyx_t_4; + ++__pyx_t_4; + __pyx_v_weight = __pyx_t_5; + __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_weight_type); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3983, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_weight.ToString()); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3983, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3983, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7); + __pyx_t_6 = 0; + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3983, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_7))) __PYX_ERR(0, 3983, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":3949 + * + * + * def shortestdistance(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kShortestDelta, + * int64 nstate=fst.kNoStateId, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pywrapfst.shortestdistance", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":3986 + * + * + * cpdef _MutableFst shortestpath(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kShortestDelta, + * int32 nshortest=1, + */ + +static PyObject *__pyx_pw_9pywrapfst_53shortestpath(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_shortestpath(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_shortestpath *__pyx_optional_args) { + float __pyx_v_delta = __pyx_k__86; + __pyx_t_10basictypes_int32 __pyx_v_nshortest = ((__pyx_t_10basictypes_int32)1); + __pyx_t_10basictypes_int64 __pyx_v_nstate = __pyx_k__87; + PyObject *__pyx_v_queue_type = ((PyObject *)__pyx_n_b_auto); + + /* "pywrapfst.pyx":3991 + * int64 nstate=fst.kNoStateId, + * queue_type=b"auto", + * bool unique=False, # <<<<<<<<<<<<<< + * weight=None): + * """ + */ + bool __pyx_v_unique = ((bool)0); + + /* "pywrapfst.pyx":3992 + * queue_type=b"auto", + * bool unique=False, + * weight=None): # <<<<<<<<<<<<<< + * """ + * shortestpath(ifst, delta=1e-6, nshortest=1, nstate=NO_STATE_ID, + */ + PyObject *__pyx_v_weight = ((PyObject *)Py_None); + std::unique_ptr __pyx_v_tfst; + fst::script::WeightClass __pyx_v_wc; + std::unique_ptr __pyx_v_opts; + struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + fst::script::WeightClass __pyx_t_1; + std::string __pyx_t_2; + enum fst::QueueType __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("shortestpath", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_delta = __pyx_optional_args->delta; + if (__pyx_optional_args->__pyx_n > 1) { + __pyx_v_nshortest = __pyx_optional_args->nshortest; + if (__pyx_optional_args->__pyx_n > 2) { + __pyx_v_nstate = __pyx_optional_args->nstate; + if (__pyx_optional_args->__pyx_n > 3) { + __pyx_v_queue_type = __pyx_optional_args->queue_type; + if (__pyx_optional_args->__pyx_n > 4) { + __pyx_v_unique = __pyx_optional_args->unique; + if (__pyx_optional_args->__pyx_n > 5) { + __pyx_v_weight = __pyx_optional_args->weight; + } + } + } + } + } + } + } + + /* "pywrapfst.pyx":4024 + * """ + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) # <<<<<<<<<<<<<< + * # Threshold is set to semiring Zero (no pruning) if no weight is specified. + * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), weight) + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "arc_type"); + __PYX_ERR(0, 4024, __pyx_L1_error) + } + __pyx_v_tfst.reset(new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->arc_type(__pyx_v_ifst, 0))); + + /* "pywrapfst.pyx":4026 + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + * # Threshold is set to semiring Zero (no pruning) if no weight is specified. + * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), weight) # <<<<<<<<<<<<<< + * cdef unique_ptr[fst.ShortestPathOptions] opts + * opts.reset(new fst.ShortestPathOptions(_get_queue_type(tostring(queue_type)), + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "weight_type"); + __PYX_ERR(0, 4026, __pyx_L1_error) + } + __pyx_t_1 = __pyx_f_9pywrapfst__get_WeightClass_or_Zero(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->weight_type(__pyx_v_ifst, 0), __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4026, __pyx_L1_error) + __pyx_v_wc = __pyx_t_1; + + /* "pywrapfst.pyx":4028 + * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), weight) + * cdef unique_ptr[fst.ShortestPathOptions] opts + * opts.reset(new fst.ShortestPathOptions(_get_queue_type(tostring(queue_type)), # <<<<<<<<<<<<<< + * nshortest, unique, delta, wc, nstate)) + * fst.ShortestPath(deref(ifst._fst), tfst.get(), deref(opts)) + */ + __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_v_queue_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4028, __pyx_L1_error) + __pyx_t_3 = __pyx_f_9pywrapfst__get_queue_type(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4028, __pyx_L1_error) + + /* "pywrapfst.pyx":4029 + * cdef unique_ptr[fst.ShortestPathOptions] opts + * opts.reset(new fst.ShortestPathOptions(_get_queue_type(tostring(queue_type)), + * nshortest, unique, delta, wc, nstate)) # <<<<<<<<<<<<<< + * fst.ShortestPath(deref(ifst._fst), tfst.get(), deref(opts)) + * return _init_MutableFst(tfst.release()) + */ + __pyx_v_opts.reset(new fst::script::ShortestPathOptions(__pyx_t_3, __pyx_v_nshortest, __pyx_v_unique, __pyx_v_delta, __pyx_v_wc, __pyx_v_nstate)); + + /* "pywrapfst.pyx":4030 + * opts.reset(new fst.ShortestPathOptions(_get_queue_type(tostring(queue_type)), + * nshortest, unique, delta, wc, nstate)) + * fst.ShortestPath(deref(ifst._fst), tfst.get(), deref(opts)) # <<<<<<<<<<<<<< + * return _init_MutableFst(tfst.release()) + * + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 4030, __pyx_L1_error) + } + fst::script::ShortestPath((*__pyx_v_ifst->_fst), __pyx_v_tfst.get(), (*__pyx_v_opts)); + + /* "pywrapfst.pyx":4031 + * nshortest, unique, delta, wc, nstate)) + * fst.ShortestPath(deref(ifst._fst), tfst.get(), deref(opts)) + * return _init_MutableFst(tfst.release()) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_4 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst.release())); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4031, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = ((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_t_4); + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":3986 + * + * + * cpdef _MutableFst shortestpath(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kShortestDelta, + * int32 nshortest=1, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pywrapfst.shortestpath", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_53shortestpath(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_52shortestpath[] = "\n shortestpath(ifst, delta=1e-6, nshortest=1, nstate=NO_STATE_ID,\n queue_type=\"auto\", unique=False, weight=None)\n\n Construct an FST containing the shortest path(s) in the input FST.\n\n This operation produces an FST containing the n-shortest paths in the input\n FST. The n-shortest paths are the n-lowest weight paths w.r.t. the natural\n semiring order. The single path that can be read from the ith of at most n\n transitions leaving the initial state of the resulting FST is the ith\n shortest path. The weights need to be right distributive and have the path\n property. They also need to be left distributive as well for n-shortest with\n n > 1 (e.g., TropicalWeight).\n\n Args:\n ifst: The input FST.\n delta: Comparison/quantization delta.\n nshortest: The number of paths to return.\n nstate: State number threshold.\n queue_type: A string matching a known queue type; one of: \"auto\", \"fifo\",\n \"lifo\", \"shortest\", \"state\", \"top\".\n unique: Should the resulting FST only contain distinct paths? (Requires\n the input FST to be an acceptor; epsilons are treated as if they are\n regular symbols.)\n weight: A Weight or weight string indicating the desired weight threshold\n below which paths are pruned; if omitted, no paths are pruned.\n\n Returns:\n An FST containing the n-shortest paths.\n "; +static PyObject *__pyx_pw_9pywrapfst_53shortestpath(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0; + float __pyx_v_delta; + __pyx_t_10basictypes_int32 __pyx_v_nshortest; + __pyx_t_10basictypes_int64 __pyx_v_nstate; + PyObject *__pyx_v_queue_type = 0; + bool __pyx_v_unique; + PyObject *__pyx_v_weight = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("shortestpath (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_delta,&__pyx_n_s_nshortest,&__pyx_n_s_nstate,&__pyx_n_s_queue_type,&__pyx_n_s_unique,&__pyx_n_s_weight,0}; + PyObject* values[7] = {0,0,0,0,0,0,0}; + values[4] = ((PyObject *)__pyx_n_b_auto); + + /* "pywrapfst.pyx":3992 + * queue_type=b"auto", + * bool unique=False, + * weight=None): # <<<<<<<<<<<<<< + * """ + * shortestpath(ifst, delta=1e-6, nshortest=1, nstate=NO_STATE_ID, + */ + values[6] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta); + if (value) { values[1] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nshortest); + if (value) { values[2] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nstate); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_queue_type); + if (value) { values[4] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_unique); + if (value) { values[5] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weight); + if (value) { values[6] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "shortestpath") < 0)) __PYX_ERR(0, 3986, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ifst = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]); + if (values[1]) { + __pyx_v_delta = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_delta == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3987, __pyx_L3_error) + } else { + __pyx_v_delta = __pyx_k__86; + } + if (values[2]) { + __pyx_v_nshortest = __Pyx_PyInt_As_int32_t(values[2]); if (unlikely((__pyx_v_nshortest == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3988, __pyx_L3_error) + } else { + __pyx_v_nshortest = ((__pyx_t_10basictypes_int32)1); + } + if (values[3]) { + __pyx_v_nstate = __Pyx_PyInt_As_int64_t(values[3]); if (unlikely((__pyx_v_nstate == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3989, __pyx_L3_error) + } else { + __pyx_v_nstate = __pyx_k__87; + } + __pyx_v_queue_type = values[4]; + if (values[5]) { + __pyx_v_unique = __Pyx_PyObject_IsTrue(values[5]); if (unlikely((__pyx_v_unique == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3991, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":3991 + * int64 nstate=fst.kNoStateId, + * queue_type=b"auto", + * bool unique=False, # <<<<<<<<<<<<<< + * weight=None): + * """ + */ + __pyx_v_unique = ((bool)0); + } + __pyx_v_weight = values[6]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("shortestpath", 0, 1, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3986, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.shortestpath", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst), __pyx_ptype_9pywrapfst__Fst, 1, "ifst", 0))) __PYX_ERR(0, 3986, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_52shortestpath(__pyx_self, __pyx_v_ifst, __pyx_v_delta, __pyx_v_nshortest, __pyx_v_nstate, __pyx_v_queue_type, __pyx_v_unique, __pyx_v_weight); + + /* "pywrapfst.pyx":3986 + * + * + * cpdef _MutableFst shortestpath(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kShortestDelta, + * int32 nshortest=1, + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_52shortestpath(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, __pyx_t_10basictypes_int32 __pyx_v_nshortest, __pyx_t_10basictypes_int64 __pyx_v_nstate, PyObject *__pyx_v_queue_type, bool __pyx_v_unique, PyObject *__pyx_v_weight) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + struct __pyx_opt_args_9pywrapfst_shortestpath __pyx_t_2; + __Pyx_RefNannySetupContext("shortestpath", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2.__pyx_n = 6; + __pyx_t_2.delta = __pyx_v_delta; + __pyx_t_2.nshortest = __pyx_v_nshortest; + __pyx_t_2.nstate = __pyx_v_nstate; + __pyx_t_2.queue_type = __pyx_v_queue_type; + __pyx_t_2.unique = __pyx_v_unique; + __pyx_t_2.weight = __pyx_v_weight; + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_shortestpath(__pyx_v_ifst, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3986, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.shortestpath", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4034 + * + * + * cpdef _Fst statemap(_Fst ifst, map_type): # <<<<<<<<<<<<<< + * """ + * state_map(ifst, map_type) + */ + +static PyObject *__pyx_pw_9pywrapfst_55statemap(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst_statemap(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, PyObject *__pyx_v_map_type, CYTHON_UNUSED int __pyx_skip_dispatch) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + struct __pyx_opt_args_9pywrapfst__map __pyx_t_2; + __Pyx_RefNannySetupContext("statemap", 0); + + /* "pywrapfst.pyx":4057 + * See also: `arcmap`. + * """ + * return _map(ifst, fst.kDelta, map_type, 1., None) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_2.__pyx_n = 4; + __pyx_t_2.delta = fst::kDelta; + __pyx_t_2.map_type = __pyx_v_map_type; + __pyx_t_2.power = 1.; + __pyx_t_2.weight = Py_None; + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__map(__pyx_v_ifst, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4057, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":4034 + * + * + * cpdef _Fst statemap(_Fst ifst, map_type): # <<<<<<<<<<<<<< + * """ + * state_map(ifst, map_type) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.statemap", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_55statemap(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_54statemap[] = "\n state_map(ifst, map_type)\n\n Constructively applies a transform to all states.\n\n This operation transforms each state according to the requested map type.\n Note that currently, only one state-mapping operation is supported.\n\n Args:\n ifst: The input FST.\n map_type: A string matching a known mapping operation; one of: \"arc_sum\"\n (sum weights of identically-labeled multi-arcs), \"arc_unique\" (deletes\n non-unique identically-labeled multi-arcs).\n\n Returns:\n An FST with states remapped.\n\n Raises:\n FstArgError: Unknown map type.\n\n See also: `arcmap`.\n "; +static PyObject *__pyx_pw_9pywrapfst_55statemap(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0; + PyObject *__pyx_v_map_type = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("statemap (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_map_type,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_map_type)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("statemap", 1, 2, 2, 1); __PYX_ERR(0, 4034, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "statemap") < 0)) __PYX_ERR(0, 4034, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_ifst = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]); + __pyx_v_map_type = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("statemap", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 4034, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.statemap", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst), __pyx_ptype_9pywrapfst__Fst, 1, "ifst", 0))) __PYX_ERR(0, 4034, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_54statemap(__pyx_self, __pyx_v_ifst, __pyx_v_map_type); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_54statemap(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, PyObject *__pyx_v_map_type) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("statemap", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_statemap(__pyx_v_ifst, __pyx_v_map_type, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4034, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.statemap", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4060 + * + * + * cpdef _MutableFst synchronize(_Fst ifst): # <<<<<<<<<<<<<< + * """ + * synchronize(ifst) + */ + +static PyObject *__pyx_pw_9pywrapfst_57synchronize(PyObject *__pyx_self, PyObject *__pyx_v_ifst); /*proto*/ +static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_synchronize(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, CYTHON_UNUSED int __pyx_skip_dispatch) { + std::unique_ptr __pyx_v_tfst; + struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("synchronize", 0); + + /* "pywrapfst.pyx":4080 + * """ + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) # <<<<<<<<<<<<<< + * fst.Synchronize(deref(ifst._fst), tfst.get()) + * return _init_MutableFst(tfst.release()) + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "arc_type"); + __PYX_ERR(0, 4080, __pyx_L1_error) + } + __pyx_v_tfst.reset(new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->arc_type(__pyx_v_ifst, 0))); + + /* "pywrapfst.pyx":4081 + * cdef unique_ptr[fst.VectorFstClass] tfst + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + * fst.Synchronize(deref(ifst._fst), tfst.get()) # <<<<<<<<<<<<<< + * return _init_MutableFst(tfst.release()) + * + */ + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 4081, __pyx_L1_error) + } + fst::script::Synchronize((*__pyx_v_ifst->_fst), __pyx_v_tfst.get()); + + /* "pywrapfst.pyx":4082 + * tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + * fst.Synchronize(deref(ifst._fst), tfst.get()) + * return _init_MutableFst(tfst.release()) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst.release())); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4082, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = ((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":4060 + * + * + * cpdef _MutableFst synchronize(_Fst ifst): # <<<<<<<<<<<<<< + * """ + * synchronize(ifst) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.synchronize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_57synchronize(PyObject *__pyx_self, PyObject *__pyx_v_ifst); /*proto*/ +static char __pyx_doc_9pywrapfst_56synchronize[] = "\n synchronize(ifst)\n\n Constructively synchronizes an FST.\n\n This operation synchronizes a transducer. The result will be an equivalent\n FST that has the property that during the traversal of a path, the delay is\n either zero or strictly increasing, where the delay is the difference between\n the number of non-epsilon output labels and input labels along the path. For\n the algorithm to terminate, the input transducer must have bounded delay,\n i.e., the delay of every cycle must be zero.\n\n Args:\n ifst: The input FST.\n\n Returns:\n An equivalent synchronized FST.\n "; +static PyObject *__pyx_pw_9pywrapfst_57synchronize(PyObject *__pyx_self, PyObject *__pyx_v_ifst) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("synchronize (wrapper)", 0); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst), __pyx_ptype_9pywrapfst__Fst, 1, "ifst", 0))) __PYX_ERR(0, 4060, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_56synchronize(__pyx_self, ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_ifst)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_56synchronize(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("synchronize", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_synchronize(__pyx_v_ifst, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4060, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.synchronize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4139 + * """ + * + * def __cinit__(self, # <<<<<<<<<<<<<< + * string fst_type=b"vector", + * string arc_type=b"standard", + */ + +/* Python wrapper */ +static int __pyx_pw_9pywrapfst_8Compiler_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_9pywrapfst_8Compiler_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + std::string __pyx_v_fst_type; + std::string __pyx_v_arc_type; + struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_isymbols = 0; + struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_osymbols = 0; + struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_ssymbols = 0; + bool __pyx_v_acceptor; + bool __pyx_v_keep_isymbols; + bool __pyx_v_keep_osymbols; + bool __pyx_v_keep_state_numbering; + bool __pyx_v_allow_negative_labels; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_fst_type,&__pyx_n_s_arc_type,&__pyx_n_s_isymbols,&__pyx_n_s_osymbols,&__pyx_n_s_ssymbols,&__pyx_n_s_acceptor,&__pyx_n_s_keep_isymbols,&__pyx_n_s_keep_osymbols,&__pyx_n_s_keep_state_numbering,&__pyx_n_s_allow_negative_labels,0}; + PyObject* values[10] = {0,0,0,0,0,0,0,0,0,0}; + + /* "pywrapfst.pyx":4142 + * string fst_type=b"vector", + * string arc_type=b"standard", + * SymbolTable isymbols=None, # <<<<<<<<<<<<<< + * SymbolTable osymbols=None, + * SymbolTable ssymbols=None, + */ + values[2] = (PyObject *)((struct __pyx_obj_9pywrapfst_SymbolTable *)Py_None); + + /* "pywrapfst.pyx":4143 + * string arc_type=b"standard", + * SymbolTable isymbols=None, + * SymbolTable osymbols=None, # <<<<<<<<<<<<<< + * SymbolTable ssymbols=None, + * bool acceptor=False, + */ + values[3] = (PyObject *)((struct __pyx_obj_9pywrapfst_SymbolTable *)Py_None); + + /* "pywrapfst.pyx":4144 + * SymbolTable isymbols=None, + * SymbolTable osymbols=None, + * SymbolTable ssymbols=None, # <<<<<<<<<<<<<< + * bool acceptor=False, + * bool keep_isymbols=False, + */ + values[4] = (PyObject *)((struct __pyx_obj_9pywrapfst_SymbolTable *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_fst_type); + if (value) { values[0] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_arc_type); + if (value) { values[1] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_isymbols); + if (value) { values[2] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_osymbols); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ssymbols); + if (value) { values[4] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_acceptor); + if (value) { values[5] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_keep_isymbols); + if (value) { values[6] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_keep_osymbols); + if (value) { values[7] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 8: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_keep_state_numbering); + if (value) { values[8] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 9: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_allow_negative_labels); + if (value) { values[9] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(0, 4139, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + if (values[0]) { + __pyx_v_fst_type = __pyx_convert_string_from_py_std__in_string(values[0]); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4140, __pyx_L3_error) + } else { + __pyx_v_fst_type = __pyx_k__88; + } + if (values[1]) { + __pyx_v_arc_type = __pyx_convert_string_from_py_std__in_string(values[1]); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4141, __pyx_L3_error) + } else { + __pyx_v_arc_type = __pyx_k__89; + } + __pyx_v_isymbols = ((struct __pyx_obj_9pywrapfst_SymbolTable *)values[2]); + __pyx_v_osymbols = ((struct __pyx_obj_9pywrapfst_SymbolTable *)values[3]); + __pyx_v_ssymbols = ((struct __pyx_obj_9pywrapfst_SymbolTable *)values[4]); + if (values[5]) { + __pyx_v_acceptor = __Pyx_PyObject_IsTrue(values[5]); if (unlikely((__pyx_v_acceptor == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4145, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":4145 + * SymbolTable osymbols=None, + * SymbolTable ssymbols=None, + * bool acceptor=False, # <<<<<<<<<<<<<< + * bool keep_isymbols=False, + * bool keep_osymbols=False, + */ + __pyx_v_acceptor = ((bool)0); + } + if (values[6]) { + __pyx_v_keep_isymbols = __Pyx_PyObject_IsTrue(values[6]); if (unlikely((__pyx_v_keep_isymbols == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4146, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":4146 + * SymbolTable ssymbols=None, + * bool acceptor=False, + * bool keep_isymbols=False, # <<<<<<<<<<<<<< + * bool keep_osymbols=False, + * bool keep_state_numbering=False, + */ + __pyx_v_keep_isymbols = ((bool)0); + } + if (values[7]) { + __pyx_v_keep_osymbols = __Pyx_PyObject_IsTrue(values[7]); if (unlikely((__pyx_v_keep_osymbols == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4147, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":4147 + * bool acceptor=False, + * bool keep_isymbols=False, + * bool keep_osymbols=False, # <<<<<<<<<<<<<< + * bool keep_state_numbering=False, + * bool allow_negative_labels=False): + */ + __pyx_v_keep_osymbols = ((bool)0); + } + if (values[8]) { + __pyx_v_keep_state_numbering = __Pyx_PyObject_IsTrue(values[8]); if (unlikely((__pyx_v_keep_state_numbering == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4148, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":4148 + * bool keep_isymbols=False, + * bool keep_osymbols=False, + * bool keep_state_numbering=False, # <<<<<<<<<<<<<< + * bool allow_negative_labels=False): + * self._sstrm.reset(new stringstream()) + */ + __pyx_v_keep_state_numbering = ((bool)0); + } + if (values[9]) { + __pyx_v_allow_negative_labels = __Pyx_PyObject_IsTrue(values[9]); if (unlikely((__pyx_v_allow_negative_labels == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4149, __pyx_L3_error) + } else { + + /* "pywrapfst.pyx":4149 + * bool keep_osymbols=False, + * bool keep_state_numbering=False, + * bool allow_negative_labels=False): # <<<<<<<<<<<<<< + * self._sstrm.reset(new stringstream()) + * self._fst_type = tostring(fst_type) + */ + __pyx_v_allow_negative_labels = ((bool)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 0, 10, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 4139, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.Compiler.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_isymbols), __pyx_ptype_9pywrapfst_SymbolTable, 1, "isymbols", 0))) __PYX_ERR(0, 4142, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_osymbols), __pyx_ptype_9pywrapfst_SymbolTable, 1, "osymbols", 0))) __PYX_ERR(0, 4143, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ssymbols), __pyx_ptype_9pywrapfst_SymbolTable, 1, "ssymbols", 0))) __PYX_ERR(0, 4144, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_8Compiler___cinit__(((struct __pyx_obj_9pywrapfst_Compiler *)__pyx_v_self), __pyx_v_fst_type, __pyx_v_arc_type, __pyx_v_isymbols, __pyx_v_osymbols, __pyx_v_ssymbols, __pyx_v_acceptor, __pyx_v_keep_isymbols, __pyx_v_keep_osymbols, __pyx_v_keep_state_numbering, __pyx_v_allow_negative_labels); + + /* "pywrapfst.pyx":4139 + * """ + * + * def __cinit__(self, # <<<<<<<<<<<<<< + * string fst_type=b"vector", + * string arc_type=b"standard", + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pywrapfst_8Compiler___cinit__(struct __pyx_obj_9pywrapfst_Compiler *__pyx_v_self, std::string __pyx_v_fst_type, std::string __pyx_v_arc_type, struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_isymbols, struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_osymbols, struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_ssymbols, bool __pyx_v_acceptor, bool __pyx_v_keep_isymbols, bool __pyx_v_keep_osymbols, bool __pyx_v_keep_state_numbering, bool __pyx_v_allow_negative_labels) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + std::string __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + fst::SymbolTable *__pyx_t_5; + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* "pywrapfst.pyx":4150 + * bool keep_state_numbering=False, + * bool allow_negative_labels=False): + * self._sstrm.reset(new stringstream()) # <<<<<<<<<<<<<< + * self._fst_type = tostring(fst_type) + * self._arc_type = tostring(arc_type) + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_sstrm"); + __PYX_ERR(0, 4150, __pyx_L1_error) + } + __pyx_v_self->_sstrm.reset(new std::stringstream()); + + /* "pywrapfst.pyx":4151 + * bool allow_negative_labels=False): + * self._sstrm.reset(new stringstream()) + * self._fst_type = tostring(fst_type) # <<<<<<<<<<<<<< + * self._arc_type = tostring(arc_type) + * self._isymbols = NULL + */ + __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_fst_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_t_1, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4151, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst_type"); + __PYX_ERR(0, 4151, __pyx_L1_error) + } + __pyx_v_self->_fst_type = __pyx_t_2; + + /* "pywrapfst.pyx":4152 + * self._sstrm.reset(new stringstream()) + * self._fst_type = tostring(fst_type) + * self._arc_type = tostring(arc_type) # <<<<<<<<<<<<<< + * self._isymbols = NULL + * if isymbols is not None: + */ + __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_arc_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_t_1, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4152, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_arc_type"); + __PYX_ERR(0, 4152, __pyx_L1_error) + } + __pyx_v_self->_arc_type = __pyx_t_2; + + /* "pywrapfst.pyx":4153 + * self._fst_type = tostring(fst_type) + * self._arc_type = tostring(arc_type) + * self._isymbols = NULL # <<<<<<<<<<<<<< + * if isymbols is not None: + * self._isymbols = isymbols._table + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_isymbols"); + __PYX_ERR(0, 4153, __pyx_L1_error) + } + __pyx_v_self->_isymbols = NULL; + + /* "pywrapfst.pyx":4154 + * self._arc_type = tostring(arc_type) + * self._isymbols = NULL + * if isymbols is not None: # <<<<<<<<<<<<<< + * self._isymbols = isymbols._table + * self._osymbols = NULL + */ + __pyx_t_3 = (((PyObject *)__pyx_v_isymbols) != Py_None); + __pyx_t_4 = (__pyx_t_3 != 0); + if (__pyx_t_4) { + + /* "pywrapfst.pyx":4155 + * self._isymbols = NULL + * if isymbols is not None: + * self._isymbols = isymbols._table # <<<<<<<<<<<<<< + * self._osymbols = NULL + * if osymbols is not None: + */ + if (unlikely(((PyObject *)__pyx_v_isymbols) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 4155, __pyx_L1_error) + } + __pyx_t_5 = __pyx_v_isymbols->__pyx_base.__pyx_base._table; + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_isymbols"); + __PYX_ERR(0, 4155, __pyx_L1_error) + } + __pyx_v_self->_isymbols = __pyx_t_5; + + /* "pywrapfst.pyx":4154 + * self._arc_type = tostring(arc_type) + * self._isymbols = NULL + * if isymbols is not None: # <<<<<<<<<<<<<< + * self._isymbols = isymbols._table + * self._osymbols = NULL + */ + } + + /* "pywrapfst.pyx":4156 + * if isymbols is not None: + * self._isymbols = isymbols._table + * self._osymbols = NULL # <<<<<<<<<<<<<< + * if osymbols is not None: + * self._osymbols = osymbols._table + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_osymbols"); + __PYX_ERR(0, 4156, __pyx_L1_error) + } + __pyx_v_self->_osymbols = NULL; + + /* "pywrapfst.pyx":4157 + * self._isymbols = isymbols._table + * self._osymbols = NULL + * if osymbols is not None: # <<<<<<<<<<<<<< + * self._osymbols = osymbols._table + * self._ssymbols = NULL + */ + __pyx_t_4 = (((PyObject *)__pyx_v_osymbols) != Py_None); + __pyx_t_3 = (__pyx_t_4 != 0); + if (__pyx_t_3) { + + /* "pywrapfst.pyx":4158 + * self._osymbols = NULL + * if osymbols is not None: + * self._osymbols = osymbols._table # <<<<<<<<<<<<<< + * self._ssymbols = NULL + * if ssymbols is not None: + */ + if (unlikely(((PyObject *)__pyx_v_osymbols) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 4158, __pyx_L1_error) + } + __pyx_t_5 = __pyx_v_osymbols->__pyx_base.__pyx_base._table; + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_osymbols"); + __PYX_ERR(0, 4158, __pyx_L1_error) + } + __pyx_v_self->_osymbols = __pyx_t_5; + + /* "pywrapfst.pyx":4157 + * self._isymbols = isymbols._table + * self._osymbols = NULL + * if osymbols is not None: # <<<<<<<<<<<<<< + * self._osymbols = osymbols._table + * self._ssymbols = NULL + */ + } + + /* "pywrapfst.pyx":4159 + * if osymbols is not None: + * self._osymbols = osymbols._table + * self._ssymbols = NULL # <<<<<<<<<<<<<< + * if ssymbols is not None: + * self._ssymbols = ssymbols._table + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_ssymbols"); + __PYX_ERR(0, 4159, __pyx_L1_error) + } + __pyx_v_self->_ssymbols = NULL; + + /* "pywrapfst.pyx":4160 + * self._osymbols = osymbols._table + * self._ssymbols = NULL + * if ssymbols is not None: # <<<<<<<<<<<<<< + * self._ssymbols = ssymbols._table + * self._acceptor = acceptor + */ + __pyx_t_3 = (((PyObject *)__pyx_v_ssymbols) != Py_None); + __pyx_t_4 = (__pyx_t_3 != 0); + if (__pyx_t_4) { + + /* "pywrapfst.pyx":4161 + * self._ssymbols = NULL + * if ssymbols is not None: + * self._ssymbols = ssymbols._table # <<<<<<<<<<<<<< + * self._acceptor = acceptor + * self._keep_isymbols = keep_isymbols + */ + if (unlikely(((PyObject *)__pyx_v_ssymbols) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); + __PYX_ERR(0, 4161, __pyx_L1_error) + } + __pyx_t_5 = __pyx_v_ssymbols->__pyx_base.__pyx_base._table; + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_ssymbols"); + __PYX_ERR(0, 4161, __pyx_L1_error) + } + __pyx_v_self->_ssymbols = __pyx_t_5; + + /* "pywrapfst.pyx":4160 + * self._osymbols = osymbols._table + * self._ssymbols = NULL + * if ssymbols is not None: # <<<<<<<<<<<<<< + * self._ssymbols = ssymbols._table + * self._acceptor = acceptor + */ + } + + /* "pywrapfst.pyx":4162 + * if ssymbols is not None: + * self._ssymbols = ssymbols._table + * self._acceptor = acceptor # <<<<<<<<<<<<<< + * self._keep_isymbols = keep_isymbols + * self._keep_osymbols = keep_osymbols + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_acceptor"); + __PYX_ERR(0, 4162, __pyx_L1_error) + } + __pyx_v_self->_acceptor = __pyx_v_acceptor; + + /* "pywrapfst.pyx":4163 + * self._ssymbols = ssymbols._table + * self._acceptor = acceptor + * self._keep_isymbols = keep_isymbols # <<<<<<<<<<<<<< + * self._keep_osymbols = keep_osymbols + * self._keep_state_numbering = keep_state_numbering + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_keep_isymbols"); + __PYX_ERR(0, 4163, __pyx_L1_error) + } + __pyx_v_self->_keep_isymbols = __pyx_v_keep_isymbols; + + /* "pywrapfst.pyx":4164 + * self._acceptor = acceptor + * self._keep_isymbols = keep_isymbols + * self._keep_osymbols = keep_osymbols # <<<<<<<<<<<<<< + * self._keep_state_numbering = keep_state_numbering + * self._allow_negative_labels = allow_negative_labels + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_keep_osymbols"); + __PYX_ERR(0, 4164, __pyx_L1_error) + } + __pyx_v_self->_keep_osymbols = __pyx_v_keep_osymbols; + + /* "pywrapfst.pyx":4165 + * self._keep_isymbols = keep_isymbols + * self._keep_osymbols = keep_osymbols + * self._keep_state_numbering = keep_state_numbering # <<<<<<<<<<<<<< + * self._allow_negative_labels = allow_negative_labels + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_keep_state_numbering"); + __PYX_ERR(0, 4165, __pyx_L1_error) + } + __pyx_v_self->_keep_state_numbering = __pyx_v_keep_state_numbering; + + /* "pywrapfst.pyx":4166 + * self._keep_osymbols = keep_osymbols + * self._keep_state_numbering = keep_state_numbering + * self._allow_negative_labels = allow_negative_labels # <<<<<<<<<<<<<< + * + * cpdef _Fst compile(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_allow_negative_labels"); + __PYX_ERR(0, 4166, __pyx_L1_error) + } + __pyx_v_self->_allow_negative_labels = __pyx_v_allow_negative_labels; + + /* "pywrapfst.pyx":4139 + * """ + * + * def __cinit__(self, # <<<<<<<<<<<<<< + * string fst_type=b"vector", + * string arc_type=b"standard", + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Compiler.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4168 + * self._allow_negative_labels = allow_negative_labels + * + * cpdef _Fst compile(self): # <<<<<<<<<<<<<< + * """ + * compile() + */ + +static PyObject *__pyx_pw_9pywrapfst_8Compiler_3compile(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst_8Compiler_compile(struct __pyx_obj_9pywrapfst_Compiler *__pyx_v_self, int __pyx_skip_dispatch) { + std::unique_ptr __pyx_v_tfst; + struct __pyx_obj_9pywrapfst__Fst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + std::string __pyx_t_5; + int __pyx_t_6; + __Pyx_RefNannySetupContext("compile", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_compile); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_8Compiler_3compile)) { + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4168, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4168, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pywrapfst__Fst))))) __PYX_ERR(0, 4168, __pyx_L1_error) + __pyx_r = ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_2); + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":4183 + * """ + * cdef unique_ptr[fst.FstClass] tfst + * tfst.reset(fst.CompileFstInternal(deref(self._sstrm), # <<<<<<<<<<<<<< + * b"", self._fst_type, self._arc_type, self._isymbols, + * self._osymbols, self._ssymbols, self._acceptor, self._keep_isymbols, + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_sstrm"); + __PYX_ERR(0, 4183, __pyx_L1_error) + } + + /* "pywrapfst.pyx":4184 + * cdef unique_ptr[fst.FstClass] tfst + * tfst.reset(fst.CompileFstInternal(deref(self._sstrm), + * b"", self._fst_type, self._arc_type, self._isymbols, # <<<<<<<<<<<<<< + * self._osymbols, self._ssymbols, self._acceptor, self._keep_isymbols, + * self._keep_osymbols, self._keep_state_numbering, + */ + __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_kp_b_pywrapfst); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4184, __pyx_L1_error) + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst_type"); + __PYX_ERR(0, 4184, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_arc_type"); + __PYX_ERR(0, 4184, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_isymbols"); + __PYX_ERR(0, 4184, __pyx_L1_error) + } + + /* "pywrapfst.pyx":4185 + * tfst.reset(fst.CompileFstInternal(deref(self._sstrm), + * b"", self._fst_type, self._arc_type, self._isymbols, + * self._osymbols, self._ssymbols, self._acceptor, self._keep_isymbols, # <<<<<<<<<<<<<< + * self._keep_osymbols, self._keep_state_numbering, + * self._allow_negative_labels)) + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_osymbols"); + __PYX_ERR(0, 4185, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_ssymbols"); + __PYX_ERR(0, 4185, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_acceptor"); + __PYX_ERR(0, 4185, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_keep_isymbols"); + __PYX_ERR(0, 4185, __pyx_L1_error) + } + + /* "pywrapfst.pyx":4186 + * b"", self._fst_type, self._arc_type, self._isymbols, + * self._osymbols, self._ssymbols, self._acceptor, self._keep_isymbols, + * self._keep_osymbols, self._keep_state_numbering, # <<<<<<<<<<<<<< + * self._allow_negative_labels)) + * self._sstrm.reset(new stringstream()) + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_keep_osymbols"); + __PYX_ERR(0, 4186, __pyx_L1_error) + } + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_keep_state_numbering"); + __PYX_ERR(0, 4186, __pyx_L1_error) + } + + /* "pywrapfst.pyx":4187 + * self._osymbols, self._ssymbols, self._acceptor, self._keep_isymbols, + * self._keep_osymbols, self._keep_state_numbering, + * self._allow_negative_labels)) # <<<<<<<<<<<<<< + * self._sstrm.reset(new stringstream()) + * if tfst.get() == NULL: + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_allow_negative_labels"); + __PYX_ERR(0, 4187, __pyx_L1_error) + } + + /* "pywrapfst.pyx":4183 + * """ + * cdef unique_ptr[fst.FstClass] tfst + * tfst.reset(fst.CompileFstInternal(deref(self._sstrm), # <<<<<<<<<<<<<< + * b"", self._fst_type, self._arc_type, self._isymbols, + * self._osymbols, self._ssymbols, self._acceptor, self._keep_isymbols, + */ + __pyx_v_tfst.reset(fst::script::CompileFstInternal((*__pyx_v_self->_sstrm), __pyx_t_5, __pyx_v_self->_fst_type, __pyx_v_self->_arc_type, __pyx_v_self->_isymbols, __pyx_v_self->_osymbols, __pyx_v_self->_ssymbols, __pyx_v_self->_acceptor, __pyx_v_self->_keep_isymbols, __pyx_v_self->_keep_osymbols, __pyx_v_self->_keep_state_numbering, __pyx_v_self->_allow_negative_labels)); + + /* "pywrapfst.pyx":4188 + * self._keep_osymbols, self._keep_state_numbering, + * self._allow_negative_labels)) + * self._sstrm.reset(new stringstream()) # <<<<<<<<<<<<<< + * if tfst.get() == NULL: + * raise FstOpError("Compilation failed") + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_sstrm"); + __PYX_ERR(0, 4188, __pyx_L1_error) + } + __pyx_v_self->_sstrm.reset(new std::stringstream()); + + /* "pywrapfst.pyx":4189 + * self._allow_negative_labels)) + * self._sstrm.reset(new stringstream()) + * if tfst.get() == NULL: # <<<<<<<<<<<<<< + * raise FstOpError("Compilation failed") + * return _init_XFst(tfst.release()) + */ + __pyx_t_6 = ((__pyx_v_tfst.get() == NULL) != 0); + if (__pyx_t_6) { + + /* "pywrapfst.pyx":4190 + * self._sstrm.reset(new stringstream()) + * if tfst.get() == NULL: + * raise FstOpError("Compilation failed") # <<<<<<<<<<<<<< + * return _init_XFst(tfst.release()) + * + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__90, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 4190, __pyx_L1_error) + + /* "pywrapfst.pyx":4189 + * self._allow_negative_labels)) + * self._sstrm.reset(new stringstream()) + * if tfst.get() == NULL: # <<<<<<<<<<<<<< + * raise FstOpError("Compilation failed") + * return _init_XFst(tfst.release()) + */ + } + + /* "pywrapfst.pyx":4191 + * if tfst.get() == NULL: + * raise FstOpError("Compilation failed") + * return _init_XFst(tfst.release()) # <<<<<<<<<<<<<< + * + * cpdef void write(self, expression): + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __pyx_t_2 = ((PyObject *)__pyx_f_9pywrapfst__init_XFst(__pyx_v_tfst.release())); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_2); + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":4168 + * self._allow_negative_labels = allow_negative_labels + * + * cpdef _Fst compile(self): # <<<<<<<<<<<<<< + * """ + * compile() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pywrapfst.Compiler.compile", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_8Compiler_3compile(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_8Compiler_2compile[] = "\n compile()\n\n Compiles the FST in the compiler string buffer.\n\n This method compiles the FST and returns the resulting machine.\n\n Returns:\n The FST described by the compiler string buffer.\n\n Raises:\n FstOpError: Compilation failed.\n "; +static PyObject *__pyx_pw_9pywrapfst_8Compiler_3compile(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("compile (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_8Compiler_2compile(((struct __pyx_obj_9pywrapfst_Compiler *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_8Compiler_2compile(struct __pyx_obj_9pywrapfst_Compiler *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("compile", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_8Compiler_compile(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Compiler.compile", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4193 + * return _init_XFst(tfst.release()) + * + * cpdef void write(self, expression): # <<<<<<<<<<<<<< + * """ + * write(expression) + */ + +static PyObject *__pyx_pw_9pywrapfst_8Compiler_5write(PyObject *__pyx_v_self, PyObject *__pyx_v_expression); /*proto*/ +static void __pyx_f_9pywrapfst_8Compiler_write(struct __pyx_obj_9pywrapfst_Compiler *__pyx_v_self, PyObject *__pyx_v_expression, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + std::string __pyx_t_6; + __Pyx_RefNannySetupContext("write", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_write); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_8Compiler_5write)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_expression); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_expression}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4193, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_expression}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4193, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_expression); + __Pyx_GIVEREF(__pyx_v_expression); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_expression); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":4209 + * expression: A string expression to add to compiler string buffer. + * """ + * deref(self._sstrm) << tostring(expression) # <<<<<<<<<<<<<< + * + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_sstrm"); + __PYX_ERR(0, 4209, __pyx_L1_error) + } + __pyx_t_6 = __pyx_f_9pywrapfst_tostring(__pyx_v_expression, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4209, __pyx_L1_error) + ((*__pyx_v_self->_sstrm) << __pyx_t_6); + + /* "pywrapfst.pyx":4193 + * return _init_XFst(tfst.release()) + * + * cpdef void write(self, expression): # <<<<<<<<<<<<<< + * """ + * write(expression) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_WriteUnraisable("pywrapfst.Compiler.write", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_8Compiler_5write(PyObject *__pyx_v_self, PyObject *__pyx_v_expression); /*proto*/ +static char __pyx_doc_9pywrapfst_8Compiler_4write[] = "\n write(expression)\n\n Writes a string into the compiler string buffer.\n\n This method adds a line to the compiler string buffer. It is normally\n invoked using the right shift operator, like so:\n\n compiler = fst.Compiler()\n print >> compiler, \"0 0 49 49\"\n print >> compiler, \"0\"\n\n Args:\n expression: A string expression to add to compiler string buffer.\n "; +static PyObject *__pyx_pw_9pywrapfst_8Compiler_5write(PyObject *__pyx_v_self, PyObject *__pyx_v_expression) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("write (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_8Compiler_4write(((struct __pyx_obj_9pywrapfst_Compiler *)__pyx_v_self), ((PyObject *)__pyx_v_expression)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_8Compiler_4write(struct __pyx_obj_9pywrapfst_Compiler *__pyx_v_self, PyObject *__pyx_v_expression) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("write", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_8Compiler_write(__pyx_v_self, __pyx_v_expression, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Compiler.write", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_8Compiler_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_8Compiler_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_8Compiler_6__reduce_cython__(((struct __pyx_obj_9pywrapfst_Compiler *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_8Compiler_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_Compiler *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__91, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Compiler.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_8Compiler_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_8Compiler_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_8Compiler_8__setstate_cython__(((struct __pyx_obj_9pywrapfst_Compiler *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_8Compiler_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_Compiler *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__92, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.Compiler.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4231 + * """ + * + * def __init__(self): # <<<<<<<<<<<<<< + * raise FstDeletedConstructorError( + * "Cannot construct {}".format(self.__class__.__name__)) + */ + +/* Python wrapper */ +static int __pyx_pw_9pywrapfst_9FarReader_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_9pywrapfst_9FarReader_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} + if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; + __pyx_r = __pyx_pf_9pywrapfst_9FarReader___init__(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pywrapfst_9FarReader___init__(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "pywrapfst.pyx":4232 + * + * def __init__(self): + * raise FstDeletedConstructorError( # <<<<<<<<<<<<<< + * "Cannot construct {}".format(self.__class__.__name__)) + * + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstDeletedConstructorError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "pywrapfst.pyx":4233 + * def __init__(self): + * raise FstDeletedConstructorError( + * "Cannot construct {}".format(self.__class__.__name__)) # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Cannot_construct, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4233, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4233, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4233, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4232, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4232, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4232, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 4232, __pyx_L1_error) + + /* "pywrapfst.pyx":4231 + * """ + * + * def __init__(self): # <<<<<<<<<<<<<< + * raise FstDeletedConstructorError( + * "Cannot construct {}".format(self.__class__.__name__)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pywrapfst.FarReader.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4235 + * "Cannot construct {}".format(self.__class__.__name__)) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "<{} FarReader at 0x{:x}>".format(self.far_type(), id(self)) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_9FarReader_3__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_9FarReader_3__repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_9FarReader_2__repr__(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_9FarReader_2__repr__(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "pywrapfst.pyx":4236 + * + * def __repr__(self): + * return "<{} FarReader at 0x{:x}>".format(self.far_type(), id(self)) # <<<<<<<<<<<<<< + * + * @classmethod + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_FarReader_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "far_type"); + __PYX_ERR(0, 4236, __pyx_L1_error) + } + __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst_FarReader *)__pyx_v_self->__pyx_vtab)->far_type(__pyx_v_self, 0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_self)); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4236, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4236, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_5); + __pyx_t_3 = 0; + __pyx_t_5 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":4235 + * "Cannot construct {}".format(self.__class__.__name__)) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "<{} FarReader at 0x{:x}>".format(self.far_type(), id(self)) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pywrapfst.FarReader.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4239 + * + * @classmethod + * def open(cls, *filenames): # <<<<<<<<<<<<<< + * """ + * FarReader.open(*filenames) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_9FarReader_5open(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_9FarReader_4open[] = "\n FarReader.open(*filenames)\n\n Creates a FarReader object.\n\n This class method creates a FarReader given the string location of one or\n more FAR files on disk.\n\n Args:\n *filenames: The string location of one or more input FAR files.\n\n Returns:\n A new FarReader instance.\n\n Raises:\n FstIOError: Read failed.\n "; +static PyObject *__pyx_pw_9pywrapfst_9FarReader_5open(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_filenames = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("open (wrapper)", 0); + if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "open", 0))) return NULL; + __Pyx_INCREF(__pyx_args); + __pyx_v_filenames = __pyx_args; + __pyx_r = __pyx_pf_9pywrapfst_9FarReader_4open(((PyTypeObject*)__pyx_v_cls), __pyx_v_filenames); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_filenames); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_9FarReader_4open(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_filenames) { + std::unique_ptr __pyx_v_tfar; + struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_result = 0; + PyObject *__pyx_v_filename = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + std::string __pyx_t_5; + std::vector __pyx_t_6; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + __Pyx_RefNannySetupContext("open", 0); + __Pyx_INCREF(__pyx_v_filenames); + + /* "pywrapfst.pyx":4257 + * FstIOError: Read failed. + * """ + * filenames = [tostring(filename) for filename in filenames] # <<<<<<<<<<<<<< + * cdef unique_ptr[fst.FarReaderClass] tfar + * tfar.reset(fst.FarReaderClass.Open(filenames)) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_v_filenames; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; + for (;;) { + if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_4); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 4257, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_XDECREF_SET(__pyx_v_filename, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_5 = __pyx_f_9pywrapfst_tostring(__pyx_v_filename, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4257, __pyx_L1_error) + __pyx_t_4 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_4))) __PYX_ERR(0, 4257, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_filenames, __pyx_t_1); + __pyx_t_1 = 0; + + /* "pywrapfst.pyx":4259 + * filenames = [tostring(filename) for filename in filenames] + * cdef unique_ptr[fst.FarReaderClass] tfar + * tfar.reset(fst.FarReaderClass.Open(filenames)) # <<<<<<<<<<<<<< + * if tfar.get() == NULL: + * raise FstIOError("Read failed: {!r}".format(filenames)) + */ + __pyx_t_6 = __pyx_convert_vector_from_py_std_3a__3a_string(__pyx_v_filenames); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4259, __pyx_L1_error) + __pyx_v_tfar.reset(fst::script::FarReaderClass::Open(__pyx_t_6)); + + /* "pywrapfst.pyx":4260 + * cdef unique_ptr[fst.FarReaderClass] tfar + * tfar.reset(fst.FarReaderClass.Open(filenames)) + * if tfar.get() == NULL: # <<<<<<<<<<<<<< + * raise FstIOError("Read failed: {!r}".format(filenames)) + * cdef FarReader result = FarReader.__new__(FarReader) + */ + __pyx_t_7 = ((__pyx_v_tfar.get() == NULL) != 0); + if (__pyx_t_7) { + + /* "pywrapfst.pyx":4261 + * tfar.reset(fst.FarReaderClass.Open(filenames)) + * if tfar.get() == NULL: + * raise FstIOError("Read failed: {!r}".format(filenames)) # <<<<<<<<<<<<<< + * cdef FarReader result = FarReader.__new__(FarReader) + * result._reader.reset(tfar.release()) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIOError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Read_failed_r, __pyx_n_s_format); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + } + } + if (!__pyx_t_9) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_filenames); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_v_filenames}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4261, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_v_filenames}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4261, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else + #endif + { + __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); __pyx_t_9 = NULL; + __Pyx_INCREF(__pyx_v_filenames); + __Pyx_GIVEREF(__pyx_v_filenames); + PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_v_filenames); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_10, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_8) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4261, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4261, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4261, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 4261, __pyx_L1_error) + + /* "pywrapfst.pyx":4260 + * cdef unique_ptr[fst.FarReaderClass] tfar + * tfar.reset(fst.FarReaderClass.Open(filenames)) + * if tfar.get() == NULL: # <<<<<<<<<<<<<< + * raise FstIOError("Read failed: {!r}".format(filenames)) + * cdef FarReader result = FarReader.__new__(FarReader) + */ + } + + /* "pywrapfst.pyx":4262 + * if tfar.get() == NULL: + * raise FstIOError("Read failed: {!r}".format(filenames)) + * cdef FarReader result = FarReader.__new__(FarReader) # <<<<<<<<<<<<<< + * result._reader.reset(tfar.release()) + * return result + */ + __pyx_t_1 = __pyx_tp_new_9pywrapfst_FarReader(((PyTypeObject *)__pyx_ptype_9pywrapfst_FarReader), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4262, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_FarReader)))) __PYX_ERR(0, 4262, __pyx_L1_error) + __pyx_v_result = ((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pywrapfst.pyx":4263 + * raise FstIOError("Read failed: {!r}".format(filenames)) + * cdef FarReader result = FarReader.__new__(FarReader) + * result._reader.reset(tfar.release()) # <<<<<<<<<<<<<< + * return result + * + */ + if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_reader"); + __PYX_ERR(0, 4263, __pyx_L1_error) + } + __pyx_v_result->_reader.reset(__pyx_v_tfar.release()); + + /* "pywrapfst.pyx":4264 + * cdef FarReader result = FarReader.__new__(FarReader) + * result._reader.reset(tfar.release()) + * return result # <<<<<<<<<<<<<< + * + * cpdef string arc_type(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "pywrapfst.pyx":4239 + * + * @classmethod + * def open(cls, *filenames): # <<<<<<<<<<<<<< + * """ + * FarReader.open(*filenames) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("pywrapfst.FarReader.open", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_filenames); + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XDECREF(__pyx_v_filename); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4266 + * return result + * + * cpdef string arc_type(self): # <<<<<<<<<<<<<< + * """ + * arc_type(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_9FarReader_7arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static std::string __pyx_f_9pywrapfst_9FarReader_arc_type(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch) { + std::string __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + std::string __pyx_t_5; + __Pyx_RefNannySetupContext("arc_type", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_arc_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_7arc_type)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4266, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4266, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4266, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":4272 + * Returns a string indicating the arc type. + * """ + * return self._reader.get().ArcType() # <<<<<<<<<<<<<< + * + * cpdef bool done(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_reader"); + __PYX_ERR(0, 4272, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_reader.get()->ArcType(); + goto __pyx_L0; + + /* "pywrapfst.pyx":4266 + * return result + * + * cpdef string arc_type(self): # <<<<<<<<<<<<<< + * """ + * arc_type(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.FarReader.arc_type", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_9FarReader_7arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_9FarReader_6arc_type[] = "\n arc_type(self)\n\n Returns a string indicating the arc type.\n "; +static PyObject *__pyx_pw_9pywrapfst_9FarReader_7arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("arc_type (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_9FarReader_6arc_type(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_9FarReader_6arc_type(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("arc_type", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_9FarReader_arc_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.FarReader.arc_type", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4274 + * return self._reader.get().ArcType() + * + * cpdef bool done(self): # <<<<<<<<<<<<<< + * """ + * done(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_9FarReader_9done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static bool __pyx_f_9pywrapfst_9FarReader_done(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch) { + bool __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + bool __pyx_t_5; + __Pyx_RefNannySetupContext("done", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_done); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_9done)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4274, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4274, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4274, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":4283 + * True if the iterator is exhausted, False otherwise. + * """ + * return self._reader.get().Done() # <<<<<<<<<<<<<< + * + * cpdef bool error(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_reader"); + __PYX_ERR(0, 4283, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_reader.get()->Done(); + goto __pyx_L0; + + /* "pywrapfst.pyx":4274 + * return self._reader.get().ArcType() + * + * cpdef bool done(self): # <<<<<<<<<<<<<< + * """ + * done(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.FarReader.done", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_9FarReader_9done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_9FarReader_8done[] = "\n done(self)\n\n Indicates whether the iterator is exhausted or not.\n\n Returns:\n True if the iterator is exhausted, False otherwise.\n "; +static PyObject *__pyx_pw_9pywrapfst_9FarReader_9done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("done (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_9FarReader_8done(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_9FarReader_8done(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("done", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_9pywrapfst_9FarReader_done(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.FarReader.done", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4285 + * return self._reader.get().Done() + * + * cpdef bool error(self): # <<<<<<<<<<<<<< + * """ + * error(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_9FarReader_11error(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static bool __pyx_f_9pywrapfst_9FarReader_error(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch) { + bool __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + bool __pyx_t_5; + __Pyx_RefNannySetupContext("error", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_11error)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4285, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4285, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4285, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":4294 + * True if the FarReader is in an errorful state, False otherwise. + * """ + * return self._reader.get().Error() # <<<<<<<<<<<<<< + * + * cpdef string far_type(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_reader"); + __PYX_ERR(0, 4294, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_reader.get()->Error(); + goto __pyx_L0; + + /* "pywrapfst.pyx":4285 + * return self._reader.get().Done() + * + * cpdef bool error(self): # <<<<<<<<<<<<<< + * """ + * error(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.FarReader.error", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_9FarReader_11error(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_9FarReader_10error[] = "\n error(self)\n\n Indicates whether the FarReader has encountered an error.\n\n Returns:\n True if the FarReader is in an errorful state, False otherwise.\n "; +static PyObject *__pyx_pw_9pywrapfst_9FarReader_11error(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("error (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_9FarReader_10error(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_9FarReader_10error(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("error", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_9pywrapfst_9FarReader_error(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.FarReader.error", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4296 + * return self._reader.get().Error() + * + * cpdef string far_type(self): # <<<<<<<<<<<<<< + * return fst.GetFarTypeString(self._reader.get().Type()) + * + */ + +static PyObject *__pyx_pw_9pywrapfst_9FarReader_13far_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static std::string __pyx_f_9pywrapfst_9FarReader_far_type(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch) { + std::string __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + std::string __pyx_t_5; + __Pyx_RefNannySetupContext("far_type", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_far_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4296, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_13far_type)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4296, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4296, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4296, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":4297 + * + * cpdef string far_type(self): + * return fst.GetFarTypeString(self._reader.get().Type()) # <<<<<<<<<<<<<< + * + * cpdef bool find(self, key) except *: + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_reader"); + __PYX_ERR(0, 4297, __pyx_L1_error) + } + __pyx_r = fst::GetFarTypeString(__pyx_v_self->_reader.get()->Type()); + goto __pyx_L0; + + /* "pywrapfst.pyx":4296 + * return self._reader.get().Error() + * + * cpdef string far_type(self): # <<<<<<<<<<<<<< + * return fst.GetFarTypeString(self._reader.get().Type()) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.FarReader.far_type", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_9FarReader_13far_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_9FarReader_13far_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("far_type (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_9FarReader_12far_type(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_9FarReader_12far_type(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("far_type", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_9FarReader_far_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4296, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.FarReader.far_type", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4299 + * return fst.GetFarTypeString(self._reader.get().Type()) + * + * cpdef bool find(self, key) except *: # <<<<<<<<<<<<<< + * """ + * find(self, key) + */ + +static PyObject *__pyx_pw_9pywrapfst_9FarReader_15find(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ +static bool __pyx_f_9pywrapfst_9FarReader_find(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, PyObject *__pyx_v_key, int __pyx_skip_dispatch) { + bool __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + bool __pyx_t_6; + std::string __pyx_t_7; + __Pyx_RefNannySetupContext("find", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_find); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_15find)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_key}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4299, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_key}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4299, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_key); + __Pyx_GIVEREF(__pyx_v_key); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_key); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_6 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4299, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_6; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":4312 + * True if the key was found, False otherwise. + * """ + * return self._reader.get().Find(tostring(key)) # <<<<<<<<<<<<<< + * + * cpdef _Fst get_fst(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_reader"); + __PYX_ERR(0, 4312, __pyx_L1_error) + } + __pyx_t_7 = __pyx_f_9pywrapfst_tostring(__pyx_v_key, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4312, __pyx_L1_error) + __pyx_r = __pyx_v_self->_reader.get()->Find(__pyx_t_7); + goto __pyx_L0; + + /* "pywrapfst.pyx":4299 + * return fst.GetFarTypeString(self._reader.get().Type()) + * + * cpdef bool find(self, key) except *: # <<<<<<<<<<<<<< + * """ + * find(self, key) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pywrapfst.FarReader.find", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_9FarReader_15find(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ +static char __pyx_doc_9pywrapfst_9FarReader_14find[] = "\n find(self, key)\n\n Sets the current position to the first entry greater than or equal to the\n key (a string) and indicates whether or not a match was found.\n\n Args:\n key: A string key.\n\n Returns:\n True if the key was found, False otherwise.\n "; +static PyObject *__pyx_pw_9pywrapfst_9FarReader_15find(PyObject *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("find (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_9FarReader_14find(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self), ((PyObject *)__pyx_v_key)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_9FarReader_14find(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + bool __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("find", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pywrapfst_9FarReader_find(__pyx_v_self, __pyx_v_key, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4299, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pywrapfst.FarReader.find", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4314 + * return self._reader.get().Find(tostring(key)) + * + * cpdef _Fst get_fst(self): # <<<<<<<<<<<<<< + * """ + * get_fst(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_9FarReader_17get_fst(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst_9FarReader_get_fst(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch) { + struct __pyx_obj_9pywrapfst__Fst *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("get_fst", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_fst); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_17get_fst)) { + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4314, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4314, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pywrapfst__Fst))))) __PYX_ERR(0, 4314, __pyx_L1_error) + __pyx_r = ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_2); + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":4323 + * A copy of the FST at the current position. + * """ + * return _init_XFst(new fst.FstClass( # <<<<<<<<<<<<<< + * deref(self._reader.get().GetFstClass()))) + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + + /* "pywrapfst.pyx":4324 + * """ + * return _init_XFst(new fst.FstClass( + * deref(self._reader.get().GetFstClass()))) # <<<<<<<<<<<<<< + * + * cpdef string get_key(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_reader"); + __PYX_ERR(0, 4324, __pyx_L1_error) + } + + /* "pywrapfst.pyx":4323 + * A copy of the FST at the current position. + * """ + * return _init_XFst(new fst.FstClass( # <<<<<<<<<<<<<< + * deref(self._reader.get().GetFstClass()))) + * + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_XFst(new fst::script::FstClass((*__pyx_v_self->_reader.get()->GetFstClass())))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4323, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":4314 + * return self._reader.get().Find(tostring(key)) + * + * cpdef _Fst get_fst(self): # <<<<<<<<<<<<<< + * """ + * get_fst(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pywrapfst.FarReader.get_fst", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_9FarReader_17get_fst(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_9FarReader_16get_fst[] = "\n get_fst(self)\n\n Returns the FST at the current position.\n\n Returns:\n A copy of the FST at the current position.\n "; +static PyObject *__pyx_pw_9pywrapfst_9FarReader_17get_fst(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_fst (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_9FarReader_16get_fst(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_9FarReader_16get_fst(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("get_fst", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_9FarReader_get_fst(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.FarReader.get_fst", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4326 + * deref(self._reader.get().GetFstClass()))) + * + * cpdef string get_key(self): # <<<<<<<<<<<<<< + * """ + * get_key(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_9FarReader_19get_key(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static std::string __pyx_f_9pywrapfst_9FarReader_get_key(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch) { + std::string __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + std::string __pyx_t_5; + __Pyx_RefNannySetupContext("get_key", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_key); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4326, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_19get_key)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4326, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4326, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4326, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":4335 + * The string key at the current position. + * """ + * return self._reader.get().GetKey() # <<<<<<<<<<<<<< + * + * cpdef void next(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_reader"); + __PYX_ERR(0, 4335, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_reader.get()->GetKey(); + goto __pyx_L0; + + /* "pywrapfst.pyx":4326 + * deref(self._reader.get().GetFstClass()))) + * + * cpdef string get_key(self): # <<<<<<<<<<<<<< + * """ + * get_key(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.FarReader.get_key", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_9FarReader_19get_key(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_9FarReader_18get_key[] = "\n get_key(self)\n\n Returns the string key at the current position.\n\n Returns:\n The string key at the current position.\n "; +static PyObject *__pyx_pw_9pywrapfst_9FarReader_19get_key(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_key (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_9FarReader_18get_key(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_9FarReader_18get_key(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("get_key", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_9FarReader_get_key(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4326, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.FarReader.get_key", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4337 + * return self._reader.get().GetKey() + * + * cpdef void next(self): # <<<<<<<<<<<<<< + * """ + * next(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_9FarReader_21next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static void __pyx_f_9pywrapfst_9FarReader_next(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("next", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_next); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4337, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_21next)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4337, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4337, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":4343 + * Advances the iterator. + * """ + * self._reader.get().Next() # <<<<<<<<<<<<<< + * + * cpdef void reset(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_reader"); + __PYX_ERR(0, 4343, __pyx_L1_error) + } + __pyx_v_self->_reader.get()->Next(); + + /* "pywrapfst.pyx":4337 + * return self._reader.get().GetKey() + * + * cpdef void next(self): # <<<<<<<<<<<<<< + * """ + * next(self) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.FarReader.next", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_9FarReader_21next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_9FarReader_20next[] = "\n next(self)\n\n Advances the iterator.\n "; +static PyObject *__pyx_pw_9pywrapfst_9FarReader_21next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("next (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_9FarReader_20next(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_9FarReader_20next(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("next", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_9FarReader_next(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4337, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.FarReader.next", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4345 + * self._reader.get().Next() + * + * cpdef void reset(self): # <<<<<<<<<<<<<< + * """ + * reset(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_9FarReader_23reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static void __pyx_f_9pywrapfst_9FarReader_reset(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("reset", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_reset); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4345, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_23reset)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4345, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4345, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":4351 + * Resets the iterator to the initial position. + * """ + * self._reader.get().Reset() # <<<<<<<<<<<<<< + * + * def __getitem__(self, key): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_reader"); + __PYX_ERR(0, 4351, __pyx_L1_error) + } + __pyx_v_self->_reader.get()->Reset(); + + /* "pywrapfst.pyx":4345 + * self._reader.get().Next() + * + * cpdef void reset(self): # <<<<<<<<<<<<<< + * """ + * reset(self) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.FarReader.reset", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_9FarReader_23reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_9FarReader_22reset[] = "\n reset(self)\n\n Resets the iterator to the initial position.\n "; +static PyObject *__pyx_pw_9pywrapfst_9FarReader_23reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("reset (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_9FarReader_22reset(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_9FarReader_22reset(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("reset", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_9FarReader_reset(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4345, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.FarReader.reset", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4353 + * self._reader.get().Reset() + * + * def __getitem__(self, key): # <<<<<<<<<<<<<< + * cdef string ckey = tostring(key) + * if self.get_key() == ckey or self._reader.get().Find(ckey): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_9FarReader_25__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_9FarReader_25__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_9FarReader_24__getitem__(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self), ((PyObject *)__pyx_v_key)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_9FarReader_24__getitem__(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, PyObject *__pyx_v_key) { + std::string __pyx_v_ckey; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + std::string __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "pywrapfst.pyx":4354 + * + * def __getitem__(self, key): + * cdef string ckey = tostring(key) # <<<<<<<<<<<<<< + * if self.get_key() == ckey or self._reader.get().Find(ckey): + * return self.get_fst() + */ + __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_key, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4354, __pyx_L1_error) + __pyx_v_ckey = __pyx_t_1; + + /* "pywrapfst.pyx":4355 + * def __getitem__(self, key): + * cdef string ckey = tostring(key) + * if self.get_key() == ckey or self._reader.get().Find(ckey): # <<<<<<<<<<<<<< + * return self.get_fst() + * raise KeyError(key) + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "get_key"); + __PYX_ERR(0, 4355, __pyx_L1_error) + } + __pyx_t_3 = ((((struct __pyx_vtabstruct_9pywrapfst_FarReader *)__pyx_v_self->__pyx_vtab)->get_key(__pyx_v_self, 0) == __pyx_v_ckey) != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_2 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_reader"); + __PYX_ERR(0, 4355, __pyx_L1_error) + } + __pyx_t_3 = (__pyx_v_self->_reader.get()->Find(__pyx_v_ckey) != 0); + __pyx_t_2 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "pywrapfst.pyx":4356 + * cdef string ckey = tostring(key) + * if self.get_key() == ckey or self._reader.get().Find(ckey): + * return self.get_fst() # <<<<<<<<<<<<<< + * raise KeyError(key) + * + */ + __Pyx_XDECREF(__pyx_r); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "get_fst"); + __PYX_ERR(0, 4356, __pyx_L1_error) + } + __pyx_t_4 = ((PyObject *)((struct __pyx_vtabstruct_9pywrapfst_FarReader *)__pyx_v_self->__pyx_vtab)->get_fst(__pyx_v_self, 0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4356, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":4355 + * def __getitem__(self, key): + * cdef string ckey = tostring(key) + * if self.get_key() == ckey or self._reader.get().Find(ckey): # <<<<<<<<<<<<<< + * return self.get_fst() + * raise KeyError(key) + */ + } + + /* "pywrapfst.pyx":4357 + * if self.get_key() == ckey or self._reader.get().Find(ckey): + * return self.get_fst() + * raise KeyError(key) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_key); + __Pyx_GIVEREF(__pyx_v_key); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_key); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 4357, __pyx_L1_error) + + /* "pywrapfst.pyx":4353 + * self._reader.get().Reset() + * + * def __getitem__(self, key): # <<<<<<<<<<<<<< + * cdef string ckey = tostring(key) + * if self.get_key() == ckey or self._reader.get().Find(ckey): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pywrapfst.FarReader.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._reader cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_9FarReader_27__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_9FarReader_27__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_9FarReader_26__reduce_cython__(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_9FarReader_26__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._reader cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._reader cannot be converted to a Python object for pickling") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__93, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._reader cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.FarReader.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._reader cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._reader cannot be converted to a Python object for pickling") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_9FarReader_29__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_9FarReader_29__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_9FarReader_28__setstate_cython__(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_9FarReader_28__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError("self._reader cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._reader cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__94, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._reader cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._reader cannot be converted to a Python object for pickling") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.FarReader.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4380 + * """ + * + * def __init__(self): # <<<<<<<<<<<<<< + * raise FstDeletedConstructorError( + * "Cannot construct {}".format(self.__class__.__name__)) + */ + +/* Python wrapper */ +static int __pyx_pw_9pywrapfst_9FarWriter_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_9pywrapfst_9FarWriter_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} + if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; + __pyx_r = __pyx_pf_9pywrapfst_9FarWriter___init__(((struct __pyx_obj_9pywrapfst_FarWriter *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pywrapfst_9FarWriter___init__(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "pywrapfst.pyx":4381 + * + * def __init__(self): + * raise FstDeletedConstructorError( # <<<<<<<<<<<<<< + * "Cannot construct {}".format(self.__class__.__name__)) + * + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstDeletedConstructorError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4381, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "pywrapfst.pyx":4382 + * def __init__(self): + * raise FstDeletedConstructorError( + * "Cannot construct {}".format(self.__class__.__name__)) # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Cannot_construct, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4382, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4382, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4382, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4381, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4381, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4381, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4381, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4381, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 4381, __pyx_L1_error) + + /* "pywrapfst.pyx":4380 + * """ + * + * def __init__(self): # <<<<<<<<<<<<<< + * raise FstDeletedConstructorError( + * "Cannot construct {}".format(self.__class__.__name__)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pywrapfst.FarWriter.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4384 + * "Cannot construct {}".format(self.__class__.__name__)) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "<{} FarWriter at 0x{:x}>".format(self.far_type(), id(self)) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_9FarWriter_3__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_9FarWriter_3__repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_9FarWriter_2__repr__(((struct __pyx_obj_9pywrapfst_FarWriter *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_9FarWriter_2__repr__(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "pywrapfst.pyx":4385 + * + * def __repr__(self): + * return "<{} FarWriter at 0x{:x}>".format(self.far_type(), id(self)) # <<<<<<<<<<<<<< + * + * @classmethod + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_FarWriter_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "far_type"); + __PYX_ERR(0, 4385, __pyx_L1_error) + } + __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst_FarWriter *)__pyx_v_self->__pyx_vtab)->far_type(__pyx_v_self, 0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_self)); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4385, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4385, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_5); + __pyx_t_3 = 0; + __pyx_t_5 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pywrapfst.pyx":4384 + * "Cannot construct {}".format(self.__class__.__name__)) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "<{} FarWriter at 0x{:x}>".format(self.far_type(), id(self)) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pywrapfst.FarWriter.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4388 + * + * @classmethod + * def create(cls, filename, arc_type=b"standard", far_type=b"default"): # <<<<<<<<<<<<<< + * """ + * FarWriter. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_9FarWriter_5create(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_9FarWriter_4create[] = "\n FarWriter.\n\n Creates a FarWriter object.\n\n This class method creates a FarWriter given the desired output location,\n arc type, and FAR type.\n\n Args:\n filename: The string location for the output FAR files.\n arc_type: A string indicating the arc type.\n far_type: A string indicating the FAR type; one of: \"fst\", \"stlist\",\n \"sttable\", \"sstable\", \"default\".\n\n Returns:\n A new FarWriter instance.\n\n Raises:\n FstIOError: Read failed.\n "; +static PyObject *__pyx_pw_9pywrapfst_9FarWriter_5create(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_filename = 0; + PyObject *__pyx_v_arc_type = 0; + PyObject *__pyx_v_far_type = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("create (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_arc_type,&__pyx_n_s_far_type,0}; + PyObject* values[3] = {0,0,0}; + values[1] = ((PyObject *)__pyx_n_b_standard); + values[2] = ((PyObject *)__pyx_n_b_default); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_filename)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_arc_type); + if (value) { values[1] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_far_type); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create") < 0)) __PYX_ERR(0, 4388, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_filename = values[0]; + __pyx_v_arc_type = values[1]; + __pyx_v_far_type = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("create", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 4388, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.FarWriter.create", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pywrapfst_9FarWriter_4create(((PyTypeObject*)__pyx_v_cls), __pyx_v_filename, __pyx_v_arc_type, __pyx_v_far_type); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_9FarWriter_4create(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_filename, PyObject *__pyx_v_arc_type, PyObject *__pyx_v_far_type) { + enum fst::FarType __pyx_v_ft; + fst::script::FarWriterClass *__pyx_v_tfar; + struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + std::string __pyx_t_1; + std::string __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + __Pyx_RefNannySetupContext("create", 0); + + /* "pywrapfst.pyx":4409 + * FstIOError: Read failed. + * """ + * cdef fst.FarType ft = fst.GetFarType(tostring(far_type)) # <<<<<<<<<<<<<< + * cdef fst.FarWriterClass *tfar = fst.FarWriterClass.Create( + * tostring(filename), tostring(arc_type), ft) + */ + __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_far_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4409, __pyx_L1_error) + __pyx_v_ft = fst::script::GetFarType(__pyx_t_1); + + /* "pywrapfst.pyx":4411 + * cdef fst.FarType ft = fst.GetFarType(tostring(far_type)) + * cdef fst.FarWriterClass *tfar = fst.FarWriterClass.Create( + * tostring(filename), tostring(arc_type), ft) # <<<<<<<<<<<<<< + * if tfar == NULL: + * raise FstIOError("Open failed: {!r}".format(filename)) + */ + __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_filename, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4411, __pyx_L1_error) + __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_v_arc_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4411, __pyx_L1_error) + + /* "pywrapfst.pyx":4410 + * """ + * cdef fst.FarType ft = fst.GetFarType(tostring(far_type)) + * cdef fst.FarWriterClass *tfar = fst.FarWriterClass.Create( # <<<<<<<<<<<<<< + * tostring(filename), tostring(arc_type), ft) + * if tfar == NULL: + */ + __pyx_v_tfar = fst::script::FarWriterClass::Create(__pyx_t_1, __pyx_t_2, __pyx_v_ft); + + /* "pywrapfst.pyx":4412 + * cdef fst.FarWriterClass *tfar = fst.FarWriterClass.Create( + * tostring(filename), tostring(arc_type), ft) + * if tfar == NULL: # <<<<<<<<<<<<<< + * raise FstIOError("Open failed: {!r}".format(filename)) + * cdef FarWriter result = FarWriter.__new__(FarWriter) + */ + __pyx_t_3 = ((__pyx_v_tfar == NULL) != 0); + if (__pyx_t_3) { + + /* "pywrapfst.pyx":4413 + * tostring(filename), tostring(arc_type), ft) + * if tfar == NULL: + * raise FstIOError("Open failed: {!r}".format(filename)) # <<<<<<<<<<<<<< + * cdef FarWriter result = FarWriter.__new__(FarWriter) + * result._writer.reset(tfar) + */ + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIOError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Open_failed_r, __pyx_n_s_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + if (!__pyx_t_8) { + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_filename); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_filename}; + __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4413, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_6); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_filename}; + __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4413, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_6); + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL; + __Pyx_INCREF(__pyx_v_filename); + __Pyx_GIVEREF(__pyx_v_filename); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_v_filename); + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (!__pyx_t_7) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4413, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4413, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4413, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 4413, __pyx_L1_error) + + /* "pywrapfst.pyx":4412 + * cdef fst.FarWriterClass *tfar = fst.FarWriterClass.Create( + * tostring(filename), tostring(arc_type), ft) + * if tfar == NULL: # <<<<<<<<<<<<<< + * raise FstIOError("Open failed: {!r}".format(filename)) + * cdef FarWriter result = FarWriter.__new__(FarWriter) + */ + } + + /* "pywrapfst.pyx":4414 + * if tfar == NULL: + * raise FstIOError("Open failed: {!r}".format(filename)) + * cdef FarWriter result = FarWriter.__new__(FarWriter) # <<<<<<<<<<<<<< + * result._writer.reset(tfar) + * return result + */ + __pyx_t_4 = __pyx_tp_new_9pywrapfst_FarWriter(((PyTypeObject *)__pyx_ptype_9pywrapfst_FarWriter), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (!(likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_9pywrapfst_FarWriter)))) __PYX_ERR(0, 4414, __pyx_L1_error) + __pyx_v_result = ((struct __pyx_obj_9pywrapfst_FarWriter *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "pywrapfst.pyx":4415 + * raise FstIOError("Open failed: {!r}".format(filename)) + * cdef FarWriter result = FarWriter.__new__(FarWriter) + * result._writer.reset(tfar) # <<<<<<<<<<<<<< + * return result + * + */ + if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_writer"); + __PYX_ERR(0, 4415, __pyx_L1_error) + } + __pyx_v_result->_writer.reset(__pyx_v_tfar); + + /* "pywrapfst.pyx":4416 + * cdef FarWriter result = FarWriter.__new__(FarWriter) + * result._writer.reset(tfar) + * return result # <<<<<<<<<<<<<< + * + * # NB: Invoking this method may be dangerous: calling any other method on the + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "pywrapfst.pyx":4388 + * + * @classmethod + * def create(cls, filename, arc_type=b"standard", far_type=b"default"): # <<<<<<<<<<<<<< + * """ + * FarWriter. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("pywrapfst.FarWriter.create", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4420 + * # NB: Invoking this method may be dangerous: calling any other method on the + * # instance after this is invoked may result in a null dereference. + * cdef void close(self): # <<<<<<<<<<<<<< + * self._writer.reset() + * + */ + +static void __pyx_f_9pywrapfst_9FarWriter_close(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("close", 0); + + /* "pywrapfst.pyx":4421 + * # instance after this is invoked may result in a null dereference. + * cdef void close(self): + * self._writer.reset() # <<<<<<<<<<<<<< + * + * cpdef void add(self, key, _Fst ifst) except *: + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_writer"); + __PYX_ERR(0, 4421, __pyx_L1_error) + } + __pyx_v_self->_writer.reset(); + + /* "pywrapfst.pyx":4420 + * # NB: Invoking this method may be dangerous: calling any other method on the + * # instance after this is invoked may result in a null dereference. + * cdef void close(self): # <<<<<<<<<<<<<< + * self._writer.reset() + * + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_WriteUnraisable("pywrapfst.FarWriter.close", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pywrapfst.pyx":4423 + * self._writer.reset() + * + * cpdef void add(self, key, _Fst ifst) except *: # <<<<<<<<<<<<<< + * """ + * add(self, key, ifst) + */ + +static PyObject *__pyx_pw_9pywrapfst_9FarWriter_7add(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static void __pyx_f_9pywrapfst_9FarWriter_add(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, PyObject *__pyx_v_key, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, int __pyx_skip_dispatch) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + std::string __pyx_t_7; + int __pyx_t_8; + __Pyx_RefNannySetupContext("add", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarWriter_7add)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + __pyx_t_5 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_key, ((PyObject *)__pyx_v_ifst)}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4423, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_key, ((PyObject *)__pyx_v_ifst)}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4423, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_INCREF(__pyx_v_key); + __Pyx_GIVEREF(__pyx_v_key); + PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, __pyx_v_key); + __Pyx_INCREF(((PyObject *)__pyx_v_ifst)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_ifst)); + PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, ((PyObject *)__pyx_v_ifst)); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":4442 + * # Failure here results from passing an FST with a different arc type than + * # used by the FAR was initialized to use. + * if not self._writer.get().Add(tostring(key), deref(ifst._fst)): # <<<<<<<<<<<<<< + * raise FstOpError("Incompatible or invalid arc type") + * # An error here usually indicates a key out of order. + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_writer"); + __PYX_ERR(0, 4442, __pyx_L1_error) + } + __pyx_t_7 = __pyx_f_9pywrapfst_tostring(__pyx_v_key, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4442, __pyx_L1_error) + if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); + __PYX_ERR(0, 4442, __pyx_L1_error) + } + __pyx_t_8 = ((!(__pyx_v_self->_writer.get()->Add(__pyx_t_7, (*__pyx_v_ifst->_fst)) != 0)) != 0); + if (__pyx_t_8) { + + /* "pywrapfst.pyx":4443 + * # used by the FAR was initialized to use. + * if not self._writer.get().Add(tostring(key), deref(ifst._fst)): + * raise FstOpError("Incompatible or invalid arc type") # <<<<<<<<<<<<<< + * # An error here usually indicates a key out of order. + * if self._writer.get().Error(): + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4443, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__95, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4443, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 4443, __pyx_L1_error) + + /* "pywrapfst.pyx":4442 + * # Failure here results from passing an FST with a different arc type than + * # used by the FAR was initialized to use. + * if not self._writer.get().Add(tostring(key), deref(ifst._fst)): # <<<<<<<<<<<<<< + * raise FstOpError("Incompatible or invalid arc type") + * # An error here usually indicates a key out of order. + */ + } + + /* "pywrapfst.pyx":4445 + * raise FstOpError("Incompatible or invalid arc type") + * # An error here usually indicates a key out of order. + * if self._writer.get().Error(): # <<<<<<<<<<<<<< + * raise FstArgError("Key out of order") + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_writer"); + __PYX_ERR(0, 4445, __pyx_L1_error) + } + __pyx_t_8 = (__pyx_v_self->_writer.get()->Error() != 0); + if (__pyx_t_8) { + + /* "pywrapfst.pyx":4446 + * # An error here usually indicates a key out of order. + * if self._writer.get().Error(): + * raise FstArgError("Key out of order") # <<<<<<<<<<<<<< + * + * cpdef string arc_type(self): + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4446, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__96, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4446, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 4446, __pyx_L1_error) + + /* "pywrapfst.pyx":4445 + * raise FstOpError("Incompatible or invalid arc type") + * # An error here usually indicates a key out of order. + * if self._writer.get().Error(): # <<<<<<<<<<<<<< + * raise FstArgError("Key out of order") + * + */ + } + + /* "pywrapfst.pyx":4423 + * self._writer.reset() + * + * cpdef void add(self, key, _Fst ifst) except *: # <<<<<<<<<<<<<< + * """ + * add(self, key, ifst) + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pywrapfst.FarWriter.add", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_9FarWriter_7add(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_9pywrapfst_9FarWriter_6add[] = "\n add(self, key, ifst)\n\n Adds an FST to the FAR.\n\n This method adds an FST to the FAR which can be retrieved with the\n specified string key.\n\n Args:\n key: The string used to key the input FST.\n ifst: The FST to write to the FAR.\n\n Raises:\n FstArgError: Key out of order.\n FstOpError: Incompatible or invalid arc type.\n "; +static PyObject *__pyx_pw_9pywrapfst_9FarWriter_7add(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_key = 0; + struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("add (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_key,&__pyx_n_s_ifst,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_key)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("add", 1, 2, 2, 1); __PYX_ERR(0, 4423, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "add") < 0)) __PYX_ERR(0, 4423, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_key = values[0]; + __pyx_v_ifst = ((struct __pyx_obj_9pywrapfst__Fst *)values[1]); + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("add", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 4423, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("pywrapfst.FarWriter.add", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst), __pyx_ptype_9pywrapfst__Fst, 1, "ifst", 0))) __PYX_ERR(0, 4423, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_9FarWriter_6add(((struct __pyx_obj_9pywrapfst_FarWriter *)__pyx_v_self), __pyx_v_key, __pyx_v_ifst); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_9FarWriter_6add(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, PyObject *__pyx_v_key, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("add", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_f_9pywrapfst_9FarWriter_add(__pyx_v_self, __pyx_v_key, __pyx_v_ifst, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4423, __pyx_L1_error) + __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.FarWriter.add", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4448 + * raise FstArgError("Key out of order") + * + * cpdef string arc_type(self): # <<<<<<<<<<<<<< + * """ + * arc_type(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_9FarWriter_9arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static std::string __pyx_f_9pywrapfst_9FarWriter_arc_type(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, int __pyx_skip_dispatch) { + std::string __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + std::string __pyx_t_5; + __Pyx_RefNannySetupContext("arc_type", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_arc_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4448, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarWriter_9arc_type)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4448, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4448, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4448, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":4454 + * Returns a string indicating the arc type. + * """ + * return self._writer.get().ArcType() # <<<<<<<<<<<<<< + * + * cpdef bool error(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_writer"); + __PYX_ERR(0, 4454, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_writer.get()->ArcType(); + goto __pyx_L0; + + /* "pywrapfst.pyx":4448 + * raise FstArgError("Key out of order") + * + * cpdef string arc_type(self): # <<<<<<<<<<<<<< + * """ + * arc_type(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.FarWriter.arc_type", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_9FarWriter_9arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_9FarWriter_8arc_type[] = "\n arc_type(self)\n\n Returns a string indicating the arc type.\n "; +static PyObject *__pyx_pw_9pywrapfst_9FarWriter_9arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("arc_type (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_9FarWriter_8arc_type(((struct __pyx_obj_9pywrapfst_FarWriter *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_9FarWriter_8arc_type(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("arc_type", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_9FarWriter_arc_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4448, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.FarWriter.arc_type", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4456 + * return self._writer.get().ArcType() + * + * cpdef bool error(self): # <<<<<<<<<<<<<< + * """ + * error(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_9FarWriter_11error(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static bool __pyx_f_9pywrapfst_9FarWriter_error(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, int __pyx_skip_dispatch) { + bool __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + bool __pyx_t_5; + __Pyx_RefNannySetupContext("error", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4456, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarWriter_11error)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4456, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4456, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4456, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":4465 + * True if the FarWriter is in an errorful state, False otherwise. + * """ + * return self._writer.get().Error() # <<<<<<<<<<<<<< + * + * cpdef string far_type(self): + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_writer"); + __PYX_ERR(0, 4465, __pyx_L1_error) + } + __pyx_r = __pyx_v_self->_writer.get()->Error(); + goto __pyx_L0; + + /* "pywrapfst.pyx":4456 + * return self._writer.get().ArcType() + * + * cpdef bool error(self): # <<<<<<<<<<<<<< + * """ + * error(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.FarWriter.error", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_9FarWriter_11error(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_9FarWriter_10error[] = "\n error(self)\n\n Indicates whether the FarWriter has encountered an error.\n\n Returns:\n True if the FarWriter is in an errorful state, False otherwise.\n "; +static PyObject *__pyx_pw_9pywrapfst_9FarWriter_11error(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("error (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_9FarWriter_10error(((struct __pyx_obj_9pywrapfst_FarWriter *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_9FarWriter_10error(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("error", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_9pywrapfst_9FarWriter_error(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4456, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.FarWriter.error", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4467 + * return self._writer.get().Error() + * + * cpdef string far_type(self): # <<<<<<<<<<<<<< + * """ + * far_type(self) + */ + +static PyObject *__pyx_pw_9pywrapfst_9FarWriter_13far_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static std::string __pyx_f_9pywrapfst_9FarWriter_far_type(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, int __pyx_skip_dispatch) { + std::string __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + std::string __pyx_t_5; + __Pyx_RefNannySetupContext("far_type", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_far_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4467, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarWriter_13far_type)) { + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4467, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4467, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4467, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "pywrapfst.pyx":4473 + * Returns a string indicating the FAR type. + * """ + * return fst.GetFarTypeString(self._writer.get().Type()) # <<<<<<<<<<<<<< + * + * # Dictionary-like assignment. + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_writer"); + __PYX_ERR(0, 4473, __pyx_L1_error) + } + __pyx_r = fst::GetFarTypeString(__pyx_v_self->_writer.get()->Type()); + goto __pyx_L0; + + /* "pywrapfst.pyx":4467 + * return self._writer.get().Error() + * + * cpdef string far_type(self): # <<<<<<<<<<<<<< + * """ + * far_type(self) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pywrapfst.FarWriter.far_type", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_9FarWriter_13far_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_9pywrapfst_9FarWriter_12far_type[] = "\n far_type(self)\n\n Returns a string indicating the FAR type.\n "; +static PyObject *__pyx_pw_9pywrapfst_9FarWriter_13far_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("far_type (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_9FarWriter_12far_type(((struct __pyx_obj_9pywrapfst_FarWriter *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_9FarWriter_12far_type(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("far_type", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_9FarWriter_far_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4467, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.FarWriter.far_type", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4476 + * + * # Dictionary-like assignment. + * def __setitem__(self, key, _Fst fst): # <<<<<<<<<<<<<< + * self.add(key, fst) + * + */ + +/* Python wrapper */ +static int __pyx_pw_9pywrapfst_9FarWriter_15__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_fst); /*proto*/ +static int __pyx_pw_9pywrapfst_9FarWriter_15__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_fst) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_fst), __pyx_ptype_9pywrapfst__Fst, 1, "fst", 0))) __PYX_ERR(0, 4476, __pyx_L1_error) + __pyx_r = __pyx_pf_9pywrapfst_9FarWriter_14__setitem__(((struct __pyx_obj_9pywrapfst_FarWriter *)__pyx_v_self), ((PyObject *)__pyx_v_key), ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_fst)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pywrapfst_9FarWriter_14__setitem__(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, PyObject *__pyx_v_key, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_fst) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__", 0); + + /* "pywrapfst.pyx":4477 + * # Dictionary-like assignment. + * def __setitem__(self, key, _Fst fst): + * self.add(key, fst) # <<<<<<<<<<<<<< + * + * + */ + if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "add"); + __PYX_ERR(0, 4477, __pyx_L1_error) + } + ((struct __pyx_vtabstruct_9pywrapfst_FarWriter *)__pyx_v_self->__pyx_vtab)->add(__pyx_v_self, __pyx_v_key, __pyx_v_fst, 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4477, __pyx_L1_error) + + /* "pywrapfst.pyx":4476 + * + * # Dictionary-like assignment. + * def __setitem__(self, key, _Fst fst): # <<<<<<<<<<<<<< + * self.add(key, fst) + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pywrapfst.FarWriter.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._writer cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_9FarWriter_17__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_9FarWriter_17__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_9FarWriter_16__reduce_cython__(((struct __pyx_obj_9pywrapfst_FarWriter *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_9FarWriter_16__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._writer cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._writer cannot be converted to a Python object for pickling") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__97, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("self._writer cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.FarWriter.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._writer cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._writer cannot be converted to a Python object for pickling") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_9FarWriter_19__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw_9pywrapfst_9FarWriter_19__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_9FarWriter_18__setstate_cython__(((struct __pyx_obj_9pywrapfst_FarWriter *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_9FarWriter_18__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError("self._writer cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._writer cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__98, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("self._writer cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("self._writer cannot be converted to a Python object for pickling") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst.FarWriter.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pywrapfst.pyx":4492 + * + * @atexit.register + * def _reset_fst_error_fatal(): # <<<<<<<<<<<<<< + * fst.FLAGS_fst_error_fatal = _fst_error_fatal_old + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pywrapfst_59_reset_fst_error_fatal(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyMethodDef __pyx_mdef_9pywrapfst_59_reset_fst_error_fatal = {"_reset_fst_error_fatal", (PyCFunction)__pyx_pw_9pywrapfst_59_reset_fst_error_fatal, METH_NOARGS, 0}; +static PyObject *__pyx_pw_9pywrapfst_59_reset_fst_error_fatal(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_reset_fst_error_fatal (wrapper)", 0); + __pyx_r = __pyx_pf_9pywrapfst_58_reset_fst_error_fatal(__pyx_self); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pywrapfst_58_reset_fst_error_fatal(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + bool __pyx_t_2; + __Pyx_RefNannySetupContext("_reset_fst_error_fatal", 0); + + /* "pywrapfst.pyx":4493 + * @atexit.register + * def _reset_fst_error_fatal(): + * fst.FLAGS_fst_error_fatal = _fst_error_fatal_old # <<<<<<<<<<<<<< + * + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_fst_error_fatal_old); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4493, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + FLAGS_fst_error_fatal = __pyx_t_2; + + /* "pywrapfst.pyx":4492 + * + * @atexit.register + * def _reset_fst_error_fatal(): # <<<<<<<<<<<<<< + * fst.FLAGS_fst_error_fatal = _fst_error_fatal_old + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pywrapfst._reset_fst_error_fatal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "string.from_py":13 + * + * @cname("__pyx_convert_string_from_py_std__in_string") + * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: # <<<<<<<<<<<<<< + * cdef Py_ssize_t length + * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) + */ + +static std::string __pyx_convert_string_from_py_std__in_string(PyObject *__pyx_v_o) { + Py_ssize_t __pyx_v_length; + char const *__pyx_v_data; + std::string __pyx_r; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + __Pyx_RefNannySetupContext("__pyx_convert_string_from_py_std__in_string", 0); + + /* "string.from_py":15 + * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: + * cdef Py_ssize_t length + * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) # <<<<<<<<<<<<<< + * return string(data, length) + * + */ + __pyx_t_1 = __Pyx_PyObject_AsStringAndSize(__pyx_v_o, (&__pyx_v_length)); if (unlikely(__pyx_t_1 == ((char const *)NULL))) __PYX_ERR(1, 15, __pyx_L1_error) + __pyx_v_data = __pyx_t_1; + + /* "string.from_py":16 + * cdef Py_ssize_t length + * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) + * return string(data, length) # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = std::string(__pyx_v_data, __pyx_v_length); + goto __pyx_L0; + + /* "string.from_py":13 + * + * @cname("__pyx_convert_string_from_py_std__in_string") + * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: # <<<<<<<<<<<<<< + * cdef Py_ssize_t length + * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("string.from_py.__pyx_convert_string_from_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "string.to_py":31 + * + * @cname("__pyx_convert_PyObject_string_to_py_std__in_string") + * cdef inline object __pyx_convert_PyObject_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< + * return __Pyx_PyObject_FromStringAndSize(s.data(), s.size()) + * cdef extern from *: + */ + +static CYTHON_INLINE PyObject *__pyx_convert_PyObject_string_to_py_std__in_string(std::string const &__pyx_v_s) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__pyx_convert_PyObject_string_to_py_std__in_string", 0); + + /* "string.to_py":32 + * @cname("__pyx_convert_PyObject_string_to_py_std__in_string") + * cdef inline object __pyx_convert_PyObject_string_to_py_std__in_string(const string& s): + * return __Pyx_PyObject_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< + * cdef extern from *: + * cdef object __Pyx_PyUnicode_FromStringAndSize(const char*, size_t) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "string.to_py":31 + * + * @cname("__pyx_convert_PyObject_string_to_py_std__in_string") + * cdef inline object __pyx_convert_PyObject_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< + * return __Pyx_PyObject_FromStringAndSize(s.data(), s.size()) + * cdef extern from *: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("string.to_py.__pyx_convert_PyObject_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "string.to_py":37 + * + * @cname("__pyx_convert_PyUnicode_string_to_py_std__in_string") + * cdef inline object __pyx_convert_PyUnicode_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< + * return __Pyx_PyUnicode_FromStringAndSize(s.data(), s.size()) + * cdef extern from *: + */ + +static CYTHON_INLINE PyObject *__pyx_convert_PyUnicode_string_to_py_std__in_string(std::string const &__pyx_v_s) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__pyx_convert_PyUnicode_string_to_py_std__in_string", 0); + + /* "string.to_py":38 + * @cname("__pyx_convert_PyUnicode_string_to_py_std__in_string") + * cdef inline object __pyx_convert_PyUnicode_string_to_py_std__in_string(const string& s): + * return __Pyx_PyUnicode_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< + * cdef extern from *: + * cdef object __Pyx_PyStr_FromStringAndSize(const char*, size_t) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyUnicode_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "string.to_py":37 + * + * @cname("__pyx_convert_PyUnicode_string_to_py_std__in_string") + * cdef inline object __pyx_convert_PyUnicode_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< + * return __Pyx_PyUnicode_FromStringAndSize(s.data(), s.size()) + * cdef extern from *: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("string.to_py.__pyx_convert_PyUnicode_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "string.to_py":43 + * + * @cname("__pyx_convert_PyStr_string_to_py_std__in_string") + * cdef inline object __pyx_convert_PyStr_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< + * return __Pyx_PyStr_FromStringAndSize(s.data(), s.size()) + * cdef extern from *: + */ + +static CYTHON_INLINE PyObject *__pyx_convert_PyStr_string_to_py_std__in_string(std::string const &__pyx_v_s) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__pyx_convert_PyStr_string_to_py_std__in_string", 0); + + /* "string.to_py":44 + * @cname("__pyx_convert_PyStr_string_to_py_std__in_string") + * cdef inline object __pyx_convert_PyStr_string_to_py_std__in_string(const string& s): + * return __Pyx_PyStr_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< + * cdef extern from *: + * cdef object __Pyx_PyBytes_FromStringAndSize(const char*, size_t) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyStr_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "string.to_py":43 + * + * @cname("__pyx_convert_PyStr_string_to_py_std__in_string") + * cdef inline object __pyx_convert_PyStr_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< + * return __Pyx_PyStr_FromStringAndSize(s.data(), s.size()) + * cdef extern from *: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("string.to_py.__pyx_convert_PyStr_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "string.to_py":49 + * + * @cname("__pyx_convert_PyBytes_string_to_py_std__in_string") + * cdef inline object __pyx_convert_PyBytes_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< + * return __Pyx_PyBytes_FromStringAndSize(s.data(), s.size()) + * cdef extern from *: + */ + +static CYTHON_INLINE PyObject *__pyx_convert_PyBytes_string_to_py_std__in_string(std::string const &__pyx_v_s) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__pyx_convert_PyBytes_string_to_py_std__in_string", 0); + + /* "string.to_py":50 + * @cname("__pyx_convert_PyBytes_string_to_py_std__in_string") + * cdef inline object __pyx_convert_PyBytes_string_to_py_std__in_string(const string& s): + * return __Pyx_PyBytes_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< + * cdef extern from *: + * cdef object __Pyx_PyByteArray_FromStringAndSize(const char*, size_t) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "string.to_py":49 + * + * @cname("__pyx_convert_PyBytes_string_to_py_std__in_string") + * cdef inline object __pyx_convert_PyBytes_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< + * return __Pyx_PyBytes_FromStringAndSize(s.data(), s.size()) + * cdef extern from *: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("string.to_py.__pyx_convert_PyBytes_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "string.to_py":55 + * + * @cname("__pyx_convert_PyByteArray_string_to_py_std__in_string") + * cdef inline object __pyx_convert_PyByteArray_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< + * return __Pyx_PyByteArray_FromStringAndSize(s.data(), s.size()) + * + */ + +static CYTHON_INLINE PyObject *__pyx_convert_PyByteArray_string_to_py_std__in_string(std::string const &__pyx_v_s) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__pyx_convert_PyByteArray_string_to_py_std__in_string", 0); + + /* "string.to_py":56 + * @cname("__pyx_convert_PyByteArray_string_to_py_std__in_string") + * cdef inline object __pyx_convert_PyByteArray_string_to_py_std__in_string(const string& s): + * return __Pyx_PyByteArray_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyByteArray_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "string.to_py":55 + * + * @cname("__pyx_convert_PyByteArray_string_to_py_std__in_string") + * cdef inline object __pyx_convert_PyByteArray_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< + * return __Pyx_PyByteArray_FromStringAndSize(s.data(), s.size()) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("string.to_py.__pyx_convert_PyByteArray_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "vector.from_py":45 + * + * @cname("__pyx_convert_vector_from_py___pyx_t_10basictypes_int64") + * cdef vector[X] __pyx_convert_vector_from_py___pyx_t_10basictypes_int64(object o) except *: # <<<<<<<<<<<<<< + * cdef vector[X] v + * for item in o: + */ + +static std::vector<__pyx_t_10basictypes_int64> __pyx_convert_vector_from_py___pyx_t_10basictypes_int64(PyObject *__pyx_v_o) { + std::vector<__pyx_t_10basictypes_int64> __pyx_v_v; + PyObject *__pyx_v_item = NULL; + std::vector<__pyx_t_10basictypes_int64> __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *(*__pyx_t_3)(PyObject *); + PyObject *__pyx_t_4 = NULL; + __pyx_t_10basictypes_int64 __pyx_t_5; + __Pyx_RefNannySetupContext("__pyx_convert_vector_from_py___pyx_t_10basictypes_int64", 0); + + /* "vector.from_py":47 + * cdef vector[X] __pyx_convert_vector_from_py___pyx_t_10basictypes_int64(object o) except *: + * cdef vector[X] v + * for item in o: # <<<<<<<<<<<<<< + * v.push_back(item) + * return v + */ + if (likely(PyList_CheckExact(__pyx_v_o)) || PyTuple_CheckExact(__pyx_v_o)) { + __pyx_t_1 = __pyx_v_o; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + __pyx_t_3 = NULL; + } else { + __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_o); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 47, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_3)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 47, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 47, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_3(__pyx_t_1); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 47, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_4); + __pyx_t_4 = 0; + + /* "vector.from_py":48 + * cdef vector[X] v + * for item in o: + * v.push_back(item) # <<<<<<<<<<<<<< + * return v + * + */ + __pyx_t_5 = __Pyx_PyInt_As_int64_t(__pyx_v_item); if (unlikely((__pyx_t_5 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(1, 48, __pyx_L1_error) + __pyx_v_v.push_back(((__pyx_t_10basictypes_int64)__pyx_t_5)); + + /* "vector.from_py":47 + * cdef vector[X] __pyx_convert_vector_from_py___pyx_t_10basictypes_int64(object o) except *: + * cdef vector[X] v + * for item in o: # <<<<<<<<<<<<<< + * v.push_back(item) + * return v + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "vector.from_py":49 + * for item in o: + * v.push_back(item) + * return v # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_v; + goto __pyx_L0; + + /* "vector.from_py":45 + * + * @cname("__pyx_convert_vector_from_py___pyx_t_10basictypes_int64") + * cdef vector[X] __pyx_convert_vector_from_py___pyx_t_10basictypes_int64(object o) except *: # <<<<<<<<<<<<<< + * cdef vector[X] v + * for item in o: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("vector.from_py.__pyx_convert_vector_from_py___pyx_t_10basictypes_int64", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_item); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static std::vector __pyx_convert_vector_from_py_std_3a__3a_string(PyObject *__pyx_v_o) { + std::vector __pyx_v_v; + PyObject *__pyx_v_item = NULL; + std::vector __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *(*__pyx_t_3)(PyObject *); + PyObject *__pyx_t_4 = NULL; + std::string __pyx_t_5; + __Pyx_RefNannySetupContext("__pyx_convert_vector_from_py_std_3a__3a_string", 0); + + /* "vector.from_py":47 + * cdef vector[X] __pyx_convert_vector_from_py_std_3a__3a_string(object o) except *: + * cdef vector[X] v + * for item in o: # <<<<<<<<<<<<<< + * v.push_back(item) + * return v + */ + if (likely(PyList_CheckExact(__pyx_v_o)) || PyTuple_CheckExact(__pyx_v_o)) { + __pyx_t_1 = __pyx_v_o; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + __pyx_t_3 = NULL; + } else { + __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_o); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 47, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_3)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 47, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 47, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_3(__pyx_t_1); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 47, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_4); + __pyx_t_4 = 0; + + /* "vector.from_py":48 + * cdef vector[X] v + * for item in o: + * v.push_back(item) # <<<<<<<<<<<<<< + * return v + * + */ + __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_v_item); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 48, __pyx_L1_error) + __pyx_v_v.push_back(((std::string)__pyx_t_5)); + + /* "vector.from_py":47 + * cdef vector[X] __pyx_convert_vector_from_py_std_3a__3a_string(object o) except *: + * cdef vector[X] v + * for item in o: # <<<<<<<<<<<<<< + * v.push_back(item) + * return v + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "vector.from_py":49 + * for item in o: + * v.push_back(item) + * return v # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_v; + goto __pyx_L0; + + /* "vector.from_py":45 + * + * @cname("__pyx_convert_vector_from_py_std_3a__3a_string") + * cdef vector[X] __pyx_convert_vector_from_py_std_3a__3a_string(object o) except *: # <<<<<<<<<<<<<< + * cdef vector[X] v + * for item in o: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("vector.from_py.__pyx_convert_vector_from_py_std_3a__3a_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_item); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static struct __pyx_vtabstruct_9pywrapfst_Weight __pyx_vtable_9pywrapfst_Weight; + +static PyObject *__pyx_tp_new_9pywrapfst_Weight(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pywrapfst_Weight *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pywrapfst_Weight *)o); + p->__pyx_vtab = __pyx_vtabptr_9pywrapfst_Weight; + new((void*)&(p->_weight)) std::unique_ptr (); + return o; +} + +static void __pyx_tp_dealloc_9pywrapfst_Weight(PyObject *o) { + struct __pyx_obj_9pywrapfst_Weight *p = (struct __pyx_obj_9pywrapfst_Weight *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + __Pyx_call_destructor(p->_weight); + (*Py_TYPE(o)->tp_free)(o); +} + +static PyObject *__pyx_tp_richcompare_9pywrapfst_Weight(PyObject *o1, PyObject *o2, int op) { + switch (op) { + case Py_EQ: { + return __pyx_pw_9pywrapfst_6Weight_17__eq__(o1, o2); + } + case Py_NE: { + return __pyx_pw_9pywrapfst_6Weight_19__ne__(o1, o2); + } + default: { + return __Pyx_NewRef(Py_NotImplemented); + } + } +} + +static PyMethodDef __pyx_methods_9pywrapfst_Weight[] = { + {"copy", (PyCFunction)__pyx_pw_9pywrapfst_6Weight_9copy, METH_NOARGS, __pyx_doc_9pywrapfst_6Weight_8copy}, + {"Zero", (PyCFunction)__pyx_pw_9pywrapfst_6Weight_11Zero, METH_O, __pyx_doc_9pywrapfst_6Weight_10Zero}, + {"One", (PyCFunction)__pyx_pw_9pywrapfst_6Weight_13One, METH_O, __pyx_doc_9pywrapfst_6Weight_12One}, + {"NoWeight", (PyCFunction)__pyx_pw_9pywrapfst_6Weight_15NoWeight, METH_O, __pyx_doc_9pywrapfst_6Weight_14NoWeight}, + {"to_string", (PyCFunction)__pyx_pw_9pywrapfst_6Weight_21to_string, METH_NOARGS, 0}, + {"type", (PyCFunction)__pyx_pw_9pywrapfst_6Weight_23type, METH_NOARGS, __pyx_doc_9pywrapfst_6Weight_22type}, + {"__reduce_cython__", (PyCFunction)__pyx_pw_9pywrapfst_6Weight_25__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw_9pywrapfst_6Weight_27__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static PyNumberMethods __pyx_tp_as_number_Weight = { + 0, /*nb_add*/ + 0, /*nb_subtract*/ + 0, /*nb_multiply*/ + #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) + 0, /*nb_divide*/ + #endif + 0, /*nb_remainder*/ + 0, /*nb_divmod*/ + 0, /*nb_power*/ + 0, /*nb_negative*/ + 0, /*nb_positive*/ + 0, /*nb_absolute*/ + 0, /*nb_nonzero*/ + 0, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + 0, /*nb_and*/ + 0, /*nb_xor*/ + 0, /*nb_or*/ + #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) + 0, /*nb_coerce*/ + #endif + 0, /*nb_int*/ + #if PY_MAJOR_VERSION < 3 + 0, /*nb_long*/ + #else + 0, /*reserved*/ + #endif + __pyx_pw_9pywrapfst_6Weight_5__float__, /*nb_float*/ + #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) + 0, /*nb_oct*/ + #endif + #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) + 0, /*nb_hex*/ + #endif + 0, /*nb_inplace_add*/ + 0, /*nb_inplace_subtract*/ + 0, /*nb_inplace_multiply*/ + #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) + 0, /*nb_inplace_divide*/ + #endif + 0, /*nb_inplace_remainder*/ + 0, /*nb_inplace_power*/ + 0, /*nb_inplace_lshift*/ + 0, /*nb_inplace_rshift*/ + 0, /*nb_inplace_and*/ + 0, /*nb_inplace_xor*/ + 0, /*nb_inplace_or*/ + 0, /*nb_floor_divide*/ + 0, /*nb_true_divide*/ + 0, /*nb_inplace_floor_divide*/ + 0, /*nb_inplace_true_divide*/ + 0, /*nb_index*/ + #if PY_VERSION_HEX >= 0x03050000 + 0, /*nb_matrix_multiply*/ + #endif + #if PY_VERSION_HEX >= 0x03050000 + 0, /*nb_inplace_matrix_multiply*/ + #endif +}; + +static PyTypeObject __pyx_type_9pywrapfst_Weight = { + PyVarObject_HEAD_INIT(0, 0) + "pywrapfst.Weight", /*tp_name*/ + sizeof(struct __pyx_obj_9pywrapfst_Weight), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pywrapfst_Weight, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pywrapfst_6Weight_1__repr__, /*tp_repr*/ + &__pyx_tp_as_number_Weight, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + __pyx_pw_9pywrapfst_6Weight_3__str__, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n Weight(weight_type, weight_string)\n\n FST weight class.\n\n This class represents an FST weight. When passed as an argument to an FST\n operation, it should have the weight type of the input FST(s) to said\n operation.\n\n Args:\n weight_type: A string indicating the weight type.\n weight_string: A string indicating the underlying weight.\n\n Raises:\n FstArgError: Weight type not found.\n FstBadWeightError: Invalid weight.\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + __pyx_tp_richcompare_9pywrapfst_Weight, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pywrapfst_Weight, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_9pywrapfst_6Weight_7__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pywrapfst_Weight, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_9pywrapfst__SymbolTable __pyx_vtable_9pywrapfst__SymbolTable; + +static PyObject *__pyx_tp_new_9pywrapfst__SymbolTable(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pywrapfst__SymbolTable *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pywrapfst__SymbolTable *)o); + p->__pyx_vtab = __pyx_vtabptr_9pywrapfst__SymbolTable; + return o; +} + +static void __pyx_tp_dealloc_9pywrapfst__SymbolTable(PyObject *o) { + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + (*Py_TYPE(o)->tp_free)(o); +} + +static PyMethodDef __pyx_methods_9pywrapfst__SymbolTable[] = { + {"available_key", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_5available_key, METH_NOARGS, __pyx_doc_9pywrapfst_12_SymbolTable_4available_key}, + {"checksum", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_7checksum, METH_NOARGS, __pyx_doc_9pywrapfst_12_SymbolTable_6checksum}, + {"copy", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_9copy, METH_NOARGS, __pyx_doc_9pywrapfst_12_SymbolTable_8copy}, + {"find", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_11find, METH_O, __pyx_doc_9pywrapfst_12_SymbolTable_10find}, + {"get_nth_key", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_13get_nth_key, METH_O, __pyx_doc_9pywrapfst_12_SymbolTable_12get_nth_key}, + {"labeled_checksum", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_15labeled_checksum, METH_NOARGS, __pyx_doc_9pywrapfst_12_SymbolTable_14labeled_checksum}, + {"member", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_17member, METH_O, __pyx_doc_9pywrapfst_12_SymbolTable_16member}, + {"name", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_21name, METH_NOARGS, __pyx_doc_9pywrapfst_12_SymbolTable_20name}, + {"num_symbols", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_23num_symbols, METH_NOARGS, __pyx_doc_9pywrapfst_12_SymbolTable_22num_symbols}, + {"write", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_25write, METH_O, __pyx_doc_9pywrapfst_12_SymbolTable_24write}, + {"write_text", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_27write_text, METH_O, __pyx_doc_9pywrapfst_12_SymbolTable_26write_text}, + {"__reduce_cython__", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_29__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_31__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static PySequenceMethods __pyx_tp_as_sequence__SymbolTable = { + 0, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + 0, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + __pyx_pw_9pywrapfst_12_SymbolTable_19__contains__, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyTypeObject __pyx_type_9pywrapfst__SymbolTable = { + PyVarObject_HEAD_INIT(0, 0) + "pywrapfst._SymbolTable", /*tp_name*/ + sizeof(struct __pyx_obj_9pywrapfst__SymbolTable), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pywrapfst__SymbolTable, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence__SymbolTable, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n (No constructor.)\n\n Base class for the symbol table hierarchy.\n\n This class is the base class for SymbolTable. It has a \"deleted\" constructor\n and implementations for the const methods of the wrapped SymbolTable.\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + __pyx_pw_9pywrapfst_12_SymbolTable_3__iter__, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pywrapfst__SymbolTable, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_9pywrapfst_12_SymbolTable_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pywrapfst__SymbolTable, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_9pywrapfst__EncodeMapperSymbolTable __pyx_vtable_9pywrapfst__EncodeMapperSymbolTable; + +static PyObject *__pyx_tp_new_9pywrapfst__EncodeMapperSymbolTable(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *p; + PyObject *o = __pyx_tp_new_9pywrapfst__SymbolTable(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *)o); + p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_9pywrapfst__SymbolTable*)__pyx_vtabptr_9pywrapfst__EncodeMapperSymbolTable; + new((void*)&(p->_encoder)) std::shared_ptr (); + return o; +} + +static void __pyx_tp_dealloc_9pywrapfst__EncodeMapperSymbolTable(PyObject *o) { + struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *p = (struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + __Pyx_call_destructor(p->_encoder); + __pyx_tp_dealloc_9pywrapfst__SymbolTable(o); +} + +static PyMethodDef __pyx_methods_9pywrapfst__EncodeMapperSymbolTable[] = { + {"__reduce_cython__", (PyCFunction)__pyx_pw_9pywrapfst_24_EncodeMapperSymbolTable_3__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw_9pywrapfst_24_EncodeMapperSymbolTable_5__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_9pywrapfst__EncodeMapperSymbolTable = { + PyVarObject_HEAD_INIT(0, 0) + "pywrapfst._EncodeMapperSymbolTable", /*tp_name*/ + sizeof(struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pywrapfst__EncodeMapperSymbolTable, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pywrapfst_24_EncodeMapperSymbolTable_1__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n (No constructor.)\n\n Immutable SymbolTable class for tables stored in an EncodeMapper.\n\n This class wraps a library const SymbolTable and exposes const methods of the\n wrapped object. It is only to be returned by method, never constructed\n directly.\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + #if CYTHON_COMPILING_IN_PYPY + __pyx_pw_9pywrapfst_12_SymbolTable_3__iter__, /*tp_iter*/ + #else + 0, /*tp_iter*/ + #endif + 0, /*tp_iternext*/ + __pyx_methods_9pywrapfst__EncodeMapperSymbolTable, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + #if CYTHON_COMPILING_IN_PYPY + __pyx_pw_9pywrapfst_12_SymbolTable_1__init__, /*tp_init*/ + #else + 0, /*tp_init*/ + #endif + 0, /*tp_alloc*/ + __pyx_tp_new_9pywrapfst__EncodeMapperSymbolTable, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_9pywrapfst__FstSymbolTable __pyx_vtable_9pywrapfst__FstSymbolTable; + +static PyObject *__pyx_tp_new_9pywrapfst__FstSymbolTable(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_9pywrapfst__FstSymbolTable *p; + PyObject *o = __pyx_tp_new_9pywrapfst__SymbolTable(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pywrapfst__FstSymbolTable *)o); + p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_9pywrapfst__SymbolTable*)__pyx_vtabptr_9pywrapfst__FstSymbolTable; + new((void*)&(p->_fst)) std::shared_ptr (); + return o; +} + +static void __pyx_tp_dealloc_9pywrapfst__FstSymbolTable(PyObject *o) { + struct __pyx_obj_9pywrapfst__FstSymbolTable *p = (struct __pyx_obj_9pywrapfst__FstSymbolTable *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + __Pyx_call_destructor(p->_fst); + __pyx_tp_dealloc_9pywrapfst__SymbolTable(o); +} + +static PyMethodDef __pyx_methods_9pywrapfst__FstSymbolTable[] = { + {"__reduce_cython__", (PyCFunction)__pyx_pw_9pywrapfst_15_FstSymbolTable_3__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw_9pywrapfst_15_FstSymbolTable_5__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_9pywrapfst__FstSymbolTable = { + PyVarObject_HEAD_INIT(0, 0) + "pywrapfst._FstSymbolTable", /*tp_name*/ + sizeof(struct __pyx_obj_9pywrapfst__FstSymbolTable), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pywrapfst__FstSymbolTable, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pywrapfst_15_FstSymbolTable_1__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n (No constructor.)\n\n Mutable SymbolTable class for tables stored in a mutable FST.\n\n This class wraps a library SymbolTable and exposes methods of the wrapped\n object. It is only to be returned by method, never constructed directly.\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + #if CYTHON_COMPILING_IN_PYPY + __pyx_pw_9pywrapfst_12_SymbolTable_3__iter__, /*tp_iter*/ + #else + 0, /*tp_iter*/ + #endif + 0, /*tp_iternext*/ + __pyx_methods_9pywrapfst__FstSymbolTable, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + #if CYTHON_COMPILING_IN_PYPY + __pyx_pw_9pywrapfst_12_SymbolTable_1__init__, /*tp_init*/ + #else + 0, /*tp_init*/ + #endif + 0, /*tp_alloc*/ + __pyx_tp_new_9pywrapfst__FstSymbolTable, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_9pywrapfst__MutableSymbolTable __pyx_vtable_9pywrapfst__MutableSymbolTable; + +static PyObject *__pyx_tp_new_9pywrapfst__MutableSymbolTable(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_9pywrapfst__MutableSymbolTable *p; + PyObject *o = __pyx_tp_new_9pywrapfst__SymbolTable(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pywrapfst__MutableSymbolTable *)o); + p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_9pywrapfst__SymbolTable*)__pyx_vtabptr_9pywrapfst__MutableSymbolTable; + return o; +} + +static PyMethodDef __pyx_methods_9pywrapfst__MutableSymbolTable[] = { + {"add_symbol", (PyCFunction)__pyx_pw_9pywrapfst_19_MutableSymbolTable_1add_symbol, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_19_MutableSymbolTable_add_symbol}, + {"add_table", (PyCFunction)__pyx_pw_9pywrapfst_19_MutableSymbolTable_3add_table, METH_O, __pyx_doc_9pywrapfst_19_MutableSymbolTable_2add_table}, + {"set_name", (PyCFunction)__pyx_pw_9pywrapfst_19_MutableSymbolTable_5set_name, METH_O, 0}, + {"__reduce_cython__", (PyCFunction)__pyx_pw_9pywrapfst_19_MutableSymbolTable_7__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw_9pywrapfst_19_MutableSymbolTable_9__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_9pywrapfst__MutableSymbolTable = { + PyVarObject_HEAD_INIT(0, 0) + "pywrapfst._MutableSymbolTable", /*tp_name*/ + sizeof(struct __pyx_obj_9pywrapfst__MutableSymbolTable), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pywrapfst__SymbolTable, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n (No constructor.)\n\n Base class for mutable symbol tables.\n\n This class is the base class for a mutable SymbolTable. It has a \"deleted\"\n constructor and implementations of all methods of the wrapped SymbolTable.\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + #if CYTHON_COMPILING_IN_PYPY + __pyx_pw_9pywrapfst_12_SymbolTable_3__iter__, /*tp_iter*/ + #else + 0, /*tp_iter*/ + #endif + 0, /*tp_iternext*/ + __pyx_methods_9pywrapfst__MutableSymbolTable, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + #if CYTHON_COMPILING_IN_PYPY + __pyx_pw_9pywrapfst_12_SymbolTable_1__init__, /*tp_init*/ + #else + 0, /*tp_init*/ + #endif + 0, /*tp_alloc*/ + __pyx_tp_new_9pywrapfst__MutableSymbolTable, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_9pywrapfst__MutableFstSymbolTable __pyx_vtable_9pywrapfst__MutableFstSymbolTable; + +static PyObject *__pyx_tp_new_9pywrapfst__MutableFstSymbolTable(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *p; + PyObject *o = __pyx_tp_new_9pywrapfst__MutableSymbolTable(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *)o); + p->__pyx_base.__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_9pywrapfst__SymbolTable*)__pyx_vtabptr_9pywrapfst__MutableFstSymbolTable; + new((void*)&(p->_mfst)) std::shared_ptr (); + return o; +} + +static void __pyx_tp_dealloc_9pywrapfst__MutableFstSymbolTable(PyObject *o) { + struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *p = (struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + __Pyx_call_destructor(p->_mfst); + __pyx_tp_dealloc_9pywrapfst__SymbolTable(o); +} + +static PyMethodDef __pyx_methods_9pywrapfst__MutableFstSymbolTable[] = { + {"__reduce_cython__", (PyCFunction)__pyx_pw_9pywrapfst_22_MutableFstSymbolTable_3__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw_9pywrapfst_22_MutableFstSymbolTable_5__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_9pywrapfst__MutableFstSymbolTable = { + PyVarObject_HEAD_INIT(0, 0) + "pywrapfst._MutableFstSymbolTable", /*tp_name*/ + sizeof(struct __pyx_obj_9pywrapfst__MutableFstSymbolTable), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pywrapfst__MutableFstSymbolTable, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pywrapfst_22_MutableFstSymbolTable_1__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n (No constructor.)\n\n Mutable SymbolTable assigned to an FST.\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + #if CYTHON_COMPILING_IN_PYPY + __pyx_pw_9pywrapfst_12_SymbolTable_3__iter__, /*tp_iter*/ + #else + 0, /*tp_iter*/ + #endif + 0, /*tp_iternext*/ + __pyx_methods_9pywrapfst__MutableFstSymbolTable, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + #if CYTHON_COMPILING_IN_PYPY + __pyx_pw_9pywrapfst_12_SymbolTable_1__init__, /*tp_init*/ + #else + 0, /*tp_init*/ + #endif + 0, /*tp_alloc*/ + __pyx_tp_new_9pywrapfst__MutableFstSymbolTable, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_9pywrapfst_SymbolTable __pyx_vtable_9pywrapfst_SymbolTable; + +static PyObject *__pyx_tp_new_9pywrapfst_SymbolTable(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_9pywrapfst_SymbolTable *p; + PyObject *o = __pyx_tp_new_9pywrapfst__MutableSymbolTable(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pywrapfst_SymbolTable *)o); + p->__pyx_base.__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_9pywrapfst__SymbolTable*)__pyx_vtabptr_9pywrapfst_SymbolTable; + new((void*)&(p->_smart_table)) std::unique_ptr (); + return o; +} + +static void __pyx_tp_dealloc_9pywrapfst_SymbolTable(PyObject *o) { + struct __pyx_obj_9pywrapfst_SymbolTable *p = (struct __pyx_obj_9pywrapfst_SymbolTable *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + __Pyx_call_destructor(p->_smart_table); + __pyx_tp_dealloc_9pywrapfst__SymbolTable(o); +} + +static PyMethodDef __pyx_methods_9pywrapfst_SymbolTable[] = { + {"read", (PyCFunction)__pyx_pw_9pywrapfst_11SymbolTable_5read, METH_O, __pyx_doc_9pywrapfst_11SymbolTable_4read}, + {"read_text", (PyCFunction)__pyx_pw_9pywrapfst_11SymbolTable_7read_text, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11SymbolTable_6read_text}, + {"read_fst", (PyCFunction)__pyx_pw_9pywrapfst_11SymbolTable_9read_fst, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11SymbolTable_8read_fst}, + {"__reduce_cython__", (PyCFunction)__pyx_pw_9pywrapfst_11SymbolTable_11__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw_9pywrapfst_11SymbolTable_13__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_9pywrapfst_SymbolTable = { + PyVarObject_HEAD_INIT(0, 0) + "pywrapfst.SymbolTable", /*tp_name*/ + sizeof(struct __pyx_obj_9pywrapfst_SymbolTable), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pywrapfst_SymbolTable, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pywrapfst_11SymbolTable_1__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n SymbolTable(name=\"\")\n\n Mutable SymbolTable class.\n\n This class wraps the library SymbolTable and exposes both const (i.e.,\n access) and non-const (i.e., mutation) methods of wrapped object.\n\n Unlike other classes in the hierarchy, it has a working constructor and can be\n used to programmatically construct a SymbolTable in memory.\n\n Args:\n name: An optional string indicating the table's name.\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + #if CYTHON_COMPILING_IN_PYPY + __pyx_pw_9pywrapfst_12_SymbolTable_3__iter__, /*tp_iter*/ + #else + 0, /*tp_iter*/ + #endif + 0, /*tp_iternext*/ + __pyx_methods_9pywrapfst_SymbolTable, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_9pywrapfst_11SymbolTable_3__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pywrapfst_SymbolTable, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_9pywrapfst_SymbolTableIterator __pyx_vtable_9pywrapfst_SymbolTableIterator; + +static PyObject *__pyx_tp_new_9pywrapfst_SymbolTableIterator(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pywrapfst_SymbolTableIterator *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pywrapfst_SymbolTableIterator *)o); + p->__pyx_vtab = __pyx_vtabptr_9pywrapfst_SymbolTableIterator; + new((void*)&(p->_table)) std::shared_ptr (); + new((void*)&(p->_siter)) std::unique_ptr (); + return o; +} + +static void __pyx_tp_dealloc_9pywrapfst_SymbolTableIterator(PyObject *o) { + struct __pyx_obj_9pywrapfst_SymbolTableIterator *p = (struct __pyx_obj_9pywrapfst_SymbolTableIterator *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + __Pyx_call_destructor(p->_table); + __Pyx_call_destructor(p->_siter); + (*Py_TYPE(o)->tp_free)(o); +} + +static PyMethodDef __pyx_methods_9pywrapfst_SymbolTableIterator[] = { + {"__next__", (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_7__next__, METH_NOARGS|METH_COEXIST, 0}, + {"done", (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_9done, METH_NOARGS, __pyx_doc_9pywrapfst_19SymbolTableIterator_8done}, + {"next", (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_11next, METH_NOARGS, __pyx_doc_9pywrapfst_19SymbolTableIterator_10next}, + {"reset", (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_13reset, METH_NOARGS, __pyx_doc_9pywrapfst_19SymbolTableIterator_12reset}, + {"symbol", (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_15symbol, METH_NOARGS, __pyx_doc_9pywrapfst_19SymbolTableIterator_14symbol}, + {"value", (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_17value, METH_NOARGS, __pyx_doc_9pywrapfst_19SymbolTableIterator_16value}, + {"__reduce_cython__", (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_19__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_21__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_9pywrapfst_SymbolTableIterator = { + PyVarObject_HEAD_INIT(0, 0) + "pywrapfst.SymbolTableIterator", /*tp_name*/ + sizeof(struct __pyx_obj_9pywrapfst_SymbolTableIterator), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pywrapfst_SymbolTableIterator, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pywrapfst_19SymbolTableIterator_1__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n SymbolTableIterator(syms)\n\n This class is used for iterating over a symbol table.\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + __pyx_pw_9pywrapfst_19SymbolTableIterator_5__iter__, /*tp_iter*/ + __pyx_pw_9pywrapfst_19SymbolTableIterator_7__next__, /*tp_iternext*/ + __pyx_methods_9pywrapfst_SymbolTableIterator, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_9pywrapfst_19SymbolTableIterator_3__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pywrapfst_SymbolTableIterator, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_9pywrapfst_EncodeMapper __pyx_vtable_9pywrapfst_EncodeMapper; + +static PyObject *__pyx_tp_new_9pywrapfst_EncodeMapper(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pywrapfst_EncodeMapper *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pywrapfst_EncodeMapper *)o); + p->__pyx_vtab = __pyx_vtabptr_9pywrapfst_EncodeMapper; + new((void*)&(p->_encoder)) std::shared_ptr (); + return o; +} + +static void __pyx_tp_dealloc_9pywrapfst_EncodeMapper(PyObject *o) { + struct __pyx_obj_9pywrapfst_EncodeMapper *p = (struct __pyx_obj_9pywrapfst_EncodeMapper *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + __Pyx_call_destructor(p->_encoder); + (*Py_TYPE(o)->tp_free)(o); +} + +static PyMethodDef __pyx_methods_9pywrapfst_EncodeMapper[] = { + {"arc_type", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_5arc_type, METH_NOARGS, __pyx_doc_9pywrapfst_12EncodeMapper_4arc_type}, + {"flags", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_9flags, METH_NOARGS, __pyx_doc_9pywrapfst_12EncodeMapper_8flags}, + {"input_symbols", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_11input_symbols, METH_NOARGS, __pyx_doc_9pywrapfst_12EncodeMapper_10input_symbols}, + {"output_symbols", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_13output_symbols, METH_NOARGS, __pyx_doc_9pywrapfst_12EncodeMapper_12output_symbols}, + {"properties", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_15properties, METH_O, __pyx_doc_9pywrapfst_12EncodeMapper_14properties}, + {"set_input_symbols", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_17set_input_symbols, METH_O, __pyx_doc_9pywrapfst_12EncodeMapper_16set_input_symbols}, + {"set_output_symbols", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_19set_output_symbols, METH_O, __pyx_doc_9pywrapfst_12EncodeMapper_18set_output_symbols}, + {"weight_type", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_21weight_type, METH_NOARGS, __pyx_doc_9pywrapfst_12EncodeMapper_20weight_type}, + {"__reduce_cython__", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_23__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_25__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_9pywrapfst_EncodeMapper = { + PyVarObject_HEAD_INIT(0, 0) + "pywrapfst.EncodeMapper", /*tp_name*/ + sizeof(struct __pyx_obj_9pywrapfst_EncodeMapper), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pywrapfst_EncodeMapper, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pywrapfst_12EncodeMapper_1__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + __pyx_pw_9pywrapfst_12EncodeMapper_7__call__, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n EncodeMapper(arc_type=\"standard\", encode_labels=False, encode_weights=False)\n\n Arc encoder class, wrapping EncodeMapperClass.\n\n This class provides an object which can be used to encode or decode FST arcs.\n This is most useful to convert an FST to an unweighted acceptor, on which\n some FST operations are more efficient, and then decoding the FST afterwards.\n\n To use an instance of this class to encode or decode a mutable FST, pass it\n as the first argument to the FST instance methods `encode` and `decode`.\n\n For implementational reasons, it is not currently possible to use an encoder\n on disk to construct this class.\n\n Args:\n arc_type: A string indicating the arc type.\n encode_labels: Should labels be encoded?\n encode_weights: Should weights be encoded?\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pywrapfst_EncodeMapper, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_9pywrapfst_12EncodeMapper_3__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pywrapfst_EncodeMapper, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_9pywrapfst__Fst __pyx_vtable_9pywrapfst__Fst; + +static PyObject *__pyx_tp_new_9pywrapfst__Fst(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pywrapfst__Fst *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pywrapfst__Fst *)o); + p->__pyx_vtab = __pyx_vtabptr_9pywrapfst__Fst; + new((void*)&(p->_fst)) std::shared_ptr (); + return o; +} + +static void __pyx_tp_dealloc_9pywrapfst__Fst(PyObject *o) { + struct __pyx_obj_9pywrapfst__Fst *p = (struct __pyx_obj_9pywrapfst__Fst *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + __Pyx_call_destructor(p->_fst); + (*Py_TYPE(o)->tp_free)(o); +} + +static PyMethodDef __pyx_methods_9pywrapfst__Fst[] = { + {"_repr_svg_", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_1_repr_svg_, METH_NOARGS, __pyx_doc_9pywrapfst_4_Fst__repr_svg_}, + {"__reduce__", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_9__reduce__, METH_NOARGS, 0}, + {"arc_type", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_11arc_type, METH_NOARGS, __pyx_doc_9pywrapfst_4_Fst_10arc_type}, + {"arcs", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_13arcs, METH_O, __pyx_doc_9pywrapfst_4_Fst_12arcs}, + {"copy", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_15copy, METH_NOARGS, __pyx_doc_9pywrapfst_4_Fst_14copy}, + {"draw", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_17draw, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_4_Fst_16draw}, + {"final", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_19final, METH_O, __pyx_doc_9pywrapfst_4_Fst_18final}, + {"fst_type", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_21fst_type, METH_NOARGS, __pyx_doc_9pywrapfst_4_Fst_20fst_type}, + {"input_symbols", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_23input_symbols, METH_NOARGS, __pyx_doc_9pywrapfst_4_Fst_22input_symbols}, + {"num_arcs", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_25num_arcs, METH_O, __pyx_doc_9pywrapfst_4_Fst_24num_arcs}, + {"num_input_epsilons", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_27num_input_epsilons, METH_O, __pyx_doc_9pywrapfst_4_Fst_26num_input_epsilons}, + {"num_output_epsilons", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_29num_output_epsilons, METH_O, __pyx_doc_9pywrapfst_4_Fst_28num_output_epsilons}, + {"output_symbols", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_31output_symbols, METH_NOARGS, __pyx_doc_9pywrapfst_4_Fst_30output_symbols}, + {"properties", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_33properties, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_4_Fst_32properties}, + {"start", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_35start, METH_NOARGS, __pyx_doc_9pywrapfst_4_Fst_34start}, + {"states", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_37states, METH_NOARGS, __pyx_doc_9pywrapfst_4_Fst_36states}, + {"text", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_39text, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_4_Fst_38text}, + {"verify", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_41verify, METH_NOARGS, __pyx_doc_9pywrapfst_4_Fst_40verify}, + {"weight_type", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_43weight_type, METH_NOARGS, __pyx_doc_9pywrapfst_4_Fst_42weight_type}, + {"write", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_45write, METH_O, __pyx_doc_9pywrapfst_4_Fst_44write}, + {"write_to_string", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_47write_to_string, METH_NOARGS, __pyx_doc_9pywrapfst_4_Fst_46write_to_string}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_9pywrapfst__Fst = { + PyVarObject_HEAD_INIT(0, 0) + "pywrapfst._Fst", /*tp_name*/ + sizeof(struct __pyx_obj_9pywrapfst__Fst), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pywrapfst__Fst, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pywrapfst_4_Fst_3__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + __pyx_pw_9pywrapfst_4_Fst_7__str__, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n (No constructor.)\n\n Immutable FST class, wrapping FstClass.\n\n This class is the basic user-facing FST object. It does not itself support any\n mutation operations.\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pywrapfst__Fst, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_9pywrapfst_4_Fst_5__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pywrapfst__Fst, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_9pywrapfst__MutableFst __pyx_vtable_9pywrapfst__MutableFst; + +static PyObject *__pyx_tp_new_9pywrapfst__MutableFst(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_9pywrapfst__MutableFst *p; + PyObject *o = __pyx_tp_new_9pywrapfst__Fst(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pywrapfst__MutableFst *)o); + p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_9pywrapfst__Fst*)__pyx_vtabptr_9pywrapfst__MutableFst; + new((void*)&(p->_mfst)) std::shared_ptr (); + return o; +} + +static void __pyx_tp_dealloc_9pywrapfst__MutableFst(PyObject *o) { + struct __pyx_obj_9pywrapfst__MutableFst *p = (struct __pyx_obj_9pywrapfst__MutableFst *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + __Pyx_call_destructor(p->_mfst); + __pyx_tp_dealloc_9pywrapfst__Fst(o); +} + +static PyMethodDef __pyx_methods_9pywrapfst__MutableFst[] = { + {"add_arc", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_1add_arc, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_add_arc}, + {"add_state", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_3add_state, METH_NOARGS, __pyx_doc_9pywrapfst_11_MutableFst_2add_state}, + {"arcsort", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_5arcsort, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_4arcsort}, + {"closure", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_7closure, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_6closure}, + {"concat", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_9concat, METH_O, __pyx_doc_9pywrapfst_11_MutableFst_8concat}, + {"connect", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_11connect, METH_NOARGS, __pyx_doc_9pywrapfst_11_MutableFst_10connect}, + {"decode", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_13decode, METH_O, __pyx_doc_9pywrapfst_11_MutableFst_12decode}, + {"delete_arcs", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_15delete_arcs, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_14delete_arcs}, + {"delete_states", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_17delete_states, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_16delete_states}, + {"encode", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_19encode, METH_O, __pyx_doc_9pywrapfst_11_MutableFst_18encode}, + {"invert", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_21invert, METH_NOARGS, __pyx_doc_9pywrapfst_11_MutableFst_20invert}, + {"minimize", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_23minimize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_22minimize}, + {"mutable_arcs", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_25mutable_arcs, METH_O, __pyx_doc_9pywrapfst_11_MutableFst_24mutable_arcs}, + {"mutable_input_symbols", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_27mutable_input_symbols, METH_NOARGS, __pyx_doc_9pywrapfst_11_MutableFst_26mutable_input_symbols}, + {"mutable_output_symbols", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_29mutable_output_symbols, METH_NOARGS, __pyx_doc_9pywrapfst_11_MutableFst_28mutable_output_symbols}, + {"num_states", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_31num_states, METH_NOARGS, __pyx_doc_9pywrapfst_11_MutableFst_30num_states}, + {"project", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_33project, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_32project}, + {"prune", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_35prune, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_34prune}, + {"push", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_37push, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_36push}, + {"relabel_pairs", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_39relabel_pairs, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_38relabel_pairs}, + {"relabel_tables", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_41relabel_tables, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_40relabel_tables}, + {"reserve_arcs", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_43reserve_arcs, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_42reserve_arcs}, + {"reserve_states", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_45reserve_states, METH_O, __pyx_doc_9pywrapfst_11_MutableFst_44reserve_states}, + {"reweight", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_47reweight, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_46reweight}, + {"rmepsilon", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_49rmepsilon, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_48rmepsilon}, + {"set_final", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_51set_final, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_50set_final}, + {"set_input_symbols", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_53set_input_symbols, METH_O, __pyx_doc_9pywrapfst_11_MutableFst_52set_input_symbols}, + {"set_output_symbols", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_55set_output_symbols, METH_O, __pyx_doc_9pywrapfst_11_MutableFst_54set_output_symbols}, + {"set_properties", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_57set_properties, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_56set_properties}, + {"set_start", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_59set_start, METH_O, __pyx_doc_9pywrapfst_11_MutableFst_58set_start}, + {"topsort", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_61topsort, METH_NOARGS, __pyx_doc_9pywrapfst_11_MutableFst_60topsort}, + {"union", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_63union, METH_O, __pyx_doc_9pywrapfst_11_MutableFst_62union}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_9pywrapfst__MutableFst = { + PyVarObject_HEAD_INIT(0, 0) + "pywrapfst._MutableFst", /*tp_name*/ + sizeof(struct __pyx_obj_9pywrapfst__MutableFst), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pywrapfst__MutableFst, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + #if CYTHON_COMPILING_IN_PYPY + __pyx_pw_9pywrapfst_4_Fst_3__repr__, /*tp_repr*/ + #else + 0, /*tp_repr*/ + #endif + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + #if CYTHON_COMPILING_IN_PYPY + __pyx_pw_9pywrapfst_4_Fst_7__str__, /*tp_str*/ + #else + 0, /*tp_str*/ + #endif + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n (No constructor.)\n\n Mutable FST class, wrapping MutableFstClass.\n\n This class extends _Fst by adding mutation operations.\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pywrapfst__MutableFst, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + #if CYTHON_COMPILING_IN_PYPY + __pyx_pw_9pywrapfst_4_Fst_5__init__, /*tp_init*/ + #else + 0, /*tp_init*/ + #endif + 0, /*tp_alloc*/ + __pyx_tp_new_9pywrapfst__MutableFst, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_9pywrapfst_Arc __pyx_vtable_9pywrapfst_Arc; + +static PyObject *__pyx_tp_new_9pywrapfst_Arc(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pywrapfst_Arc *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pywrapfst_Arc *)o); + p->__pyx_vtab = __pyx_vtabptr_9pywrapfst_Arc; + new((void*)&(p->_arc)) std::unique_ptr (); + return o; +} + +static void __pyx_tp_dealloc_9pywrapfst_Arc(PyObject *o) { + struct __pyx_obj_9pywrapfst_Arc *p = (struct __pyx_obj_9pywrapfst_Arc *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + __Pyx_call_destructor(p->_arc); + (*Py_TYPE(o)->tp_free)(o); +} + +static PyObject *__pyx_getprop_9pywrapfst_3Arc_ilabel(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pywrapfst_3Arc_6ilabel_1__get__(o); +} + +static int __pyx_setprop_9pywrapfst_3Arc_ilabel(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pywrapfst_3Arc_6ilabel_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_9pywrapfst_3Arc_olabel(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pywrapfst_3Arc_6olabel_1__get__(o); +} + +static int __pyx_setprop_9pywrapfst_3Arc_olabel(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pywrapfst_3Arc_6olabel_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_9pywrapfst_3Arc_weight(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pywrapfst_3Arc_6weight_1__get__(o); +} + +static int __pyx_setprop_9pywrapfst_3Arc_weight(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pywrapfst_3Arc_6weight_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_9pywrapfst_3Arc_nextstate(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pywrapfst_3Arc_9nextstate_1__get__(o); +} + +static int __pyx_setprop_9pywrapfst_3Arc_nextstate(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pywrapfst_3Arc_9nextstate_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyMethodDef __pyx_methods_9pywrapfst_Arc[] = { + {"copy", (PyCFunction)__pyx_pw_9pywrapfst_3Arc_5copy, METH_NOARGS, 0}, + {"__reduce_cython__", (PyCFunction)__pyx_pw_9pywrapfst_3Arc_7__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw_9pywrapfst_3Arc_9__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pywrapfst_Arc[] = { + {(char *)"ilabel", __pyx_getprop_9pywrapfst_3Arc_ilabel, __pyx_setprop_9pywrapfst_3Arc_ilabel, (char *)0, 0}, + {(char *)"olabel", __pyx_getprop_9pywrapfst_3Arc_olabel, __pyx_setprop_9pywrapfst_3Arc_olabel, (char *)0, 0}, + {(char *)"weight", __pyx_getprop_9pywrapfst_3Arc_weight, __pyx_setprop_9pywrapfst_3Arc_weight, (char *)0, 0}, + {(char *)"nextstate", __pyx_getprop_9pywrapfst_3Arc_nextstate, __pyx_setprop_9pywrapfst_3Arc_nextstate, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_9pywrapfst_Arc = { + PyVarObject_HEAD_INIT(0, 0) + "pywrapfst.Arc", /*tp_name*/ + sizeof(struct __pyx_obj_9pywrapfst_Arc), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pywrapfst_Arc, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pywrapfst_3Arc_1__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n Arc(ilabel, olabel, weight, nextstate)\n\n This class represents an arc while remaining agnostic about the underlying arc\n type. Attributes of the arc can be accessed or mutated, and the arc can be\n copied.\n\n Attributes:\n ilabel: The input label.\n olabel: The output label.\n weight: The arc weight.\n nextstate: The destination state for the arc.\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pywrapfst_Arc, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pywrapfst_Arc, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_9pywrapfst_3Arc_3__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pywrapfst_Arc, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_9pywrapfst_ArcIterator __pyx_vtable_9pywrapfst_ArcIterator; + +static PyObject *__pyx_tp_new_9pywrapfst_ArcIterator(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pywrapfst_ArcIterator *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pywrapfst_ArcIterator *)o); + p->__pyx_vtab = __pyx_vtabptr_9pywrapfst_ArcIterator; + new((void*)&(p->_fst)) std::shared_ptr (); + new((void*)&(p->_aiter)) std::unique_ptr (); + return o; +} + +static void __pyx_tp_dealloc_9pywrapfst_ArcIterator(PyObject *o) { + struct __pyx_obj_9pywrapfst_ArcIterator *p = (struct __pyx_obj_9pywrapfst_ArcIterator *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + __Pyx_call_destructor(p->_fst); + __Pyx_call_destructor(p->_aiter); + (*Py_TYPE(o)->tp_free)(o); +} + +static PyMethodDef __pyx_methods_9pywrapfst_ArcIterator[] = { + {"__next__", (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_7__next__, METH_NOARGS|METH_COEXIST, 0}, + {"done", (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_9done, METH_NOARGS, __pyx_doc_9pywrapfst_11ArcIterator_8done}, + {"flags", (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_11flags, METH_NOARGS, __pyx_doc_9pywrapfst_11ArcIterator_10flags}, + {"next", (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_13next, METH_NOARGS, __pyx_doc_9pywrapfst_11ArcIterator_12next}, + {"position", (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_15position, METH_NOARGS, __pyx_doc_9pywrapfst_11ArcIterator_14position}, + {"reset", (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_17reset, METH_NOARGS, __pyx_doc_9pywrapfst_11ArcIterator_16reset}, + {"seek", (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_19seek, METH_O, __pyx_doc_9pywrapfst_11ArcIterator_18seek}, + {"set_flags", (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_21set_flags, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11ArcIterator_20set_flags}, + {"value", (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_23value, METH_NOARGS, __pyx_doc_9pywrapfst_11ArcIterator_22value}, + {"__reduce_cython__", (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_25__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_27__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_9pywrapfst_ArcIterator = { + PyVarObject_HEAD_INIT(0, 0) + "pywrapfst.ArcIterator", /*tp_name*/ + sizeof(struct __pyx_obj_9pywrapfst_ArcIterator), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pywrapfst_ArcIterator, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pywrapfst_11ArcIterator_1__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n ArcIterator(ifst, state)\n\n This class is used for iterating over the arcs leaving some state of an FST.\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + __pyx_pw_9pywrapfst_11ArcIterator_5__iter__, /*tp_iter*/ + __pyx_pw_9pywrapfst_11ArcIterator_7__next__, /*tp_iternext*/ + __pyx_methods_9pywrapfst_ArcIterator, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_9pywrapfst_11ArcIterator_3__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pywrapfst_ArcIterator, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_9pywrapfst_MutableArcIterator __pyx_vtable_9pywrapfst_MutableArcIterator; + +static PyObject *__pyx_tp_new_9pywrapfst_MutableArcIterator(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pywrapfst_MutableArcIterator *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pywrapfst_MutableArcIterator *)o); + p->__pyx_vtab = __pyx_vtabptr_9pywrapfst_MutableArcIterator; + new((void*)&(p->_mfst)) std::shared_ptr (); + new((void*)&(p->_aiter)) std::unique_ptr (); + return o; +} + +static void __pyx_tp_dealloc_9pywrapfst_MutableArcIterator(PyObject *o) { + struct __pyx_obj_9pywrapfst_MutableArcIterator *p = (struct __pyx_obj_9pywrapfst_MutableArcIterator *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + __Pyx_call_destructor(p->_mfst); + __Pyx_call_destructor(p->_aiter); + (*Py_TYPE(o)->tp_free)(o); +} + +static PyMethodDef __pyx_methods_9pywrapfst_MutableArcIterator[] = { + {"done", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_5done, METH_NOARGS, __pyx_doc_9pywrapfst_18MutableArcIterator_4done}, + {"flags", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_7flags, METH_NOARGS, __pyx_doc_9pywrapfst_18MutableArcIterator_6flags}, + {"next", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_9next, METH_NOARGS, __pyx_doc_9pywrapfst_18MutableArcIterator_8next}, + {"position", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_11position, METH_NOARGS, __pyx_doc_9pywrapfst_18MutableArcIterator_10position}, + {"reset", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_13reset, METH_NOARGS, __pyx_doc_9pywrapfst_18MutableArcIterator_12reset}, + {"seek", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_15seek, METH_O, __pyx_doc_9pywrapfst_18MutableArcIterator_14seek}, + {"set_flags", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_17set_flags, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_18MutableArcIterator_16set_flags}, + {"set_value", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_19set_value, METH_O, __pyx_doc_9pywrapfst_18MutableArcIterator_18set_value}, + {"value", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_21value, METH_NOARGS, __pyx_doc_9pywrapfst_18MutableArcIterator_20value}, + {"__reduce_cython__", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_23__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_25__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_9pywrapfst_MutableArcIterator = { + PyVarObject_HEAD_INIT(0, 0) + "pywrapfst.MutableArcIterator", /*tp_name*/ + sizeof(struct __pyx_obj_9pywrapfst_MutableArcIterator), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pywrapfst_MutableArcIterator, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pywrapfst_18MutableArcIterator_1__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n MutableArcIterator(ifst, state)\n\n This class is used for iterating over the arcs leaving some state of an FST,\n also permitting mutation of the current arc.\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pywrapfst_MutableArcIterator, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_9pywrapfst_18MutableArcIterator_3__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pywrapfst_MutableArcIterator, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_9pywrapfst_StateIterator __pyx_vtable_9pywrapfst_StateIterator; + +static PyObject *__pyx_tp_new_9pywrapfst_StateIterator(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pywrapfst_StateIterator *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pywrapfst_StateIterator *)o); + p->__pyx_vtab = __pyx_vtabptr_9pywrapfst_StateIterator; + new((void*)&(p->_fst)) std::shared_ptr (); + new((void*)&(p->_siter)) std::unique_ptr (); + return o; +} + +static void __pyx_tp_dealloc_9pywrapfst_StateIterator(PyObject *o) { + struct __pyx_obj_9pywrapfst_StateIterator *p = (struct __pyx_obj_9pywrapfst_StateIterator *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + __Pyx_call_destructor(p->_fst); + __Pyx_call_destructor(p->_siter); + (*Py_TYPE(o)->tp_free)(o); +} + +static PyMethodDef __pyx_methods_9pywrapfst_StateIterator[] = { + {"__next__", (PyCFunction)__pyx_pw_9pywrapfst_13StateIterator_7__next__, METH_NOARGS|METH_COEXIST, 0}, + {"done", (PyCFunction)__pyx_pw_9pywrapfst_13StateIterator_9done, METH_NOARGS, __pyx_doc_9pywrapfst_13StateIterator_8done}, + {"next", (PyCFunction)__pyx_pw_9pywrapfst_13StateIterator_11next, METH_NOARGS, __pyx_doc_9pywrapfst_13StateIterator_10next}, + {"reset", (PyCFunction)__pyx_pw_9pywrapfst_13StateIterator_13reset, METH_NOARGS, __pyx_doc_9pywrapfst_13StateIterator_12reset}, + {"value", (PyCFunction)__pyx_pw_9pywrapfst_13StateIterator_15value, METH_NOARGS, __pyx_doc_9pywrapfst_13StateIterator_14value}, + {"__reduce_cython__", (PyCFunction)__pyx_pw_9pywrapfst_13StateIterator_17__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw_9pywrapfst_13StateIterator_19__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_9pywrapfst_StateIterator = { + PyVarObject_HEAD_INIT(0, 0) + "pywrapfst.StateIterator", /*tp_name*/ + sizeof(struct __pyx_obj_9pywrapfst_StateIterator), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pywrapfst_StateIterator, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pywrapfst_13StateIterator_1__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n StateIterator(ifst)\n\n This class is used for iterating over the states in an FST.\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + __pyx_pw_9pywrapfst_13StateIterator_5__iter__, /*tp_iter*/ + __pyx_pw_9pywrapfst_13StateIterator_7__next__, /*tp_iternext*/ + __pyx_methods_9pywrapfst_StateIterator, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_9pywrapfst_13StateIterator_3__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pywrapfst_StateIterator, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_9pywrapfst_Compiler __pyx_vtable_9pywrapfst_Compiler; + +static PyObject *__pyx_tp_new_9pywrapfst_Compiler(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_9pywrapfst_Compiler *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pywrapfst_Compiler *)o); + p->__pyx_vtab = __pyx_vtabptr_9pywrapfst_Compiler; + new((void*)&(p->_sstrm)) std::unique_ptr (); + new((void*)&(p->_fst_type)) std::string(); + new((void*)&(p->_arc_type)) std::string(); + if (unlikely(__pyx_pw_9pywrapfst_8Compiler_1__cinit__(o, a, k) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_9pywrapfst_Compiler(PyObject *o) { + struct __pyx_obj_9pywrapfst_Compiler *p = (struct __pyx_obj_9pywrapfst_Compiler *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + __Pyx_call_destructor(p->_sstrm); + __Pyx_call_destructor(p->_fst_type); + __Pyx_call_destructor(p->_arc_type); + (*Py_TYPE(o)->tp_free)(o); +} + +static PyMethodDef __pyx_methods_9pywrapfst_Compiler[] = { + {"compile", (PyCFunction)__pyx_pw_9pywrapfst_8Compiler_3compile, METH_NOARGS, __pyx_doc_9pywrapfst_8Compiler_2compile}, + {"write", (PyCFunction)__pyx_pw_9pywrapfst_8Compiler_5write, METH_O, __pyx_doc_9pywrapfst_8Compiler_4write}, + {"__reduce_cython__", (PyCFunction)__pyx_pw_9pywrapfst_8Compiler_7__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw_9pywrapfst_8Compiler_9__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_9pywrapfst_Compiler = { + PyVarObject_HEAD_INIT(0, 0) + "pywrapfst.Compiler", /*tp_name*/ + sizeof(struct __pyx_obj_9pywrapfst_Compiler), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pywrapfst_Compiler, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n Compiler(fst_type=\"vector\", arc_type=\"standard\", isymbols=None,\n osymbols=None, ssymbols=None, acceptor=False, keep_isymbols=False,\n keep_osymbols=False, keep_state_numbering=False,\n allow_negative_labels=False)\n\n Class used to compile FSTs from strings.\n\n This class is used to compile FSTs specified using the AT&T FSM library\n format described here:\n\n http://web.eecs.umich.edu/~radev/NLP-fall2015/resources/fsm_archive/fsm.5.html\n\n This is the same format used by the `fstcompile` executable.\n\n Compiler options (symbol tables, etc.) are set at construction time.\n\n compiler = fst.Compiler(isymbols=ascii_syms, osymbols=ascii_syms)\n\n Once constructed, Compiler instances behave like a file handle opened for\n writing:\n\n # /ba+/\n print >> compiler, \"0 1 50 50\"\n print >> compiler, \"1 2 49 49\"\n print >> compiler, \"2 2 49 49\"\n print >> compiler, \"2\"\n\n The `compile` method returns an actual FST instance:\n\n sheep_machine = compiler.compile()\n\n Compilation flushes the internal buffer, so the compiler instance can be\n reused to compile new machines with the same symbol tables (etc.)\n\n Args:\n fst_type: A string indicating the container type for the compiled FST.\n arc_type: A string indicating the arc type for the compiled FST.\n isymbols: An optional SymbolTable used to label input symbols.\n osymbols: An optional SymbolTable used to label output symbols.\n ssymbols: An optional SymbolTable used to label states.\n acceptor: Should the FST be rendered in acceptor format if possible?\n keep_isymbols: Should the input symbol table be stored in the FST?\n keep_osymbols: Should the output symbol table be stored in the FST?\n keep_state_numbering: Should the state numbering be preserved?\n allow_negative_labels: Should negative labels be allowed? (Not\n recommended; may cause conflicts).\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pywrapfst_Compiler, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pywrapfst_Compiler, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_9pywrapfst_FarReader __pyx_vtable_9pywrapfst_FarReader; + +static PyObject *__pyx_tp_new_9pywrapfst_FarReader(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pywrapfst_FarReader *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pywrapfst_FarReader *)o); + p->__pyx_vtab = __pyx_vtabptr_9pywrapfst_FarReader; + new((void*)&(p->_reader)) std::unique_ptr (); + return o; +} + +static void __pyx_tp_dealloc_9pywrapfst_FarReader(PyObject *o) { + struct __pyx_obj_9pywrapfst_FarReader *p = (struct __pyx_obj_9pywrapfst_FarReader *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + __Pyx_call_destructor(p->_reader); + (*Py_TYPE(o)->tp_free)(o); +} +static PyObject *__pyx_sq_item_9pywrapfst_FarReader(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static PyMethodDef __pyx_methods_9pywrapfst_FarReader[] = { + {"open", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_5open, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_9FarReader_4open}, + {"arc_type", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_7arc_type, METH_NOARGS, __pyx_doc_9pywrapfst_9FarReader_6arc_type}, + {"done", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_9done, METH_NOARGS, __pyx_doc_9pywrapfst_9FarReader_8done}, + {"error", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_11error, METH_NOARGS, __pyx_doc_9pywrapfst_9FarReader_10error}, + {"far_type", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_13far_type, METH_NOARGS, 0}, + {"find", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_15find, METH_O, __pyx_doc_9pywrapfst_9FarReader_14find}, + {"get_fst", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_17get_fst, METH_NOARGS, __pyx_doc_9pywrapfst_9FarReader_16get_fst}, + {"get_key", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_19get_key, METH_NOARGS, __pyx_doc_9pywrapfst_9FarReader_18get_key}, + {"next", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_21next, METH_NOARGS, __pyx_doc_9pywrapfst_9FarReader_20next}, + {"reset", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_23reset, METH_NOARGS, __pyx_doc_9pywrapfst_9FarReader_22reset}, + {"__reduce_cython__", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_27__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_29__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static PySequenceMethods __pyx_tp_as_sequence_FarReader = { + 0, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_9pywrapfst_FarReader, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_FarReader = { + 0, /*mp_length*/ + __pyx_pw_9pywrapfst_9FarReader_25__getitem__, /*mp_subscript*/ + 0, /*mp_ass_subscript*/ +}; + +static PyTypeObject __pyx_type_9pywrapfst_FarReader = { + PyVarObject_HEAD_INIT(0, 0) + "pywrapfst.FarReader", /*tp_name*/ + sizeof(struct __pyx_obj_9pywrapfst_FarReader), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pywrapfst_FarReader, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pywrapfst_9FarReader_3__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_FarReader, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_FarReader, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n (No constructor.)\n\n FAR (\"Fst ARchive\") reader object.\n\n This class is used to read a FAR from disk. FARs contain one or more FSTs (of\n the same arc type) indexed by a unique string key. To construct a FarReader\n object, use the `open` class method.\n\n Attributes:\n arc_type: A string indicating the arc type.\n far_type: A string indicating the FAR type.\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pywrapfst_FarReader, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_9pywrapfst_9FarReader_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pywrapfst_FarReader, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_9pywrapfst_FarWriter __pyx_vtable_9pywrapfst_FarWriter; + +static PyObject *__pyx_tp_new_9pywrapfst_FarWriter(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pywrapfst_FarWriter *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pywrapfst_FarWriter *)o); + p->__pyx_vtab = __pyx_vtabptr_9pywrapfst_FarWriter; + new((void*)&(p->_writer)) std::unique_ptr (); + return o; +} + +static void __pyx_tp_dealloc_9pywrapfst_FarWriter(PyObject *o) { + struct __pyx_obj_9pywrapfst_FarWriter *p = (struct __pyx_obj_9pywrapfst_FarWriter *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + __Pyx_call_destructor(p->_writer); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_mp_ass_subscript_9pywrapfst_FarWriter(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_pw_9pywrapfst_9FarWriter_15__setitem__(o, i, v); + } + else { + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); + return -1; + } +} + +static PyMethodDef __pyx_methods_9pywrapfst_FarWriter[] = { + {"create", (PyCFunction)__pyx_pw_9pywrapfst_9FarWriter_5create, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_9FarWriter_4create}, + {"add", (PyCFunction)__pyx_pw_9pywrapfst_9FarWriter_7add, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_9FarWriter_6add}, + {"arc_type", (PyCFunction)__pyx_pw_9pywrapfst_9FarWriter_9arc_type, METH_NOARGS, __pyx_doc_9pywrapfst_9FarWriter_8arc_type}, + {"error", (PyCFunction)__pyx_pw_9pywrapfst_9FarWriter_11error, METH_NOARGS, __pyx_doc_9pywrapfst_9FarWriter_10error}, + {"far_type", (PyCFunction)__pyx_pw_9pywrapfst_9FarWriter_13far_type, METH_NOARGS, __pyx_doc_9pywrapfst_9FarWriter_12far_type}, + {"__reduce_cython__", (PyCFunction)__pyx_pw_9pywrapfst_9FarWriter_17__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw_9pywrapfst_9FarWriter_19__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static PyMappingMethods __pyx_tp_as_mapping_FarWriter = { + 0, /*mp_length*/ + 0, /*mp_subscript*/ + __pyx_mp_ass_subscript_9pywrapfst_FarWriter, /*mp_ass_subscript*/ +}; + +static PyTypeObject __pyx_type_9pywrapfst_FarWriter = { + PyVarObject_HEAD_INIT(0, 0) + "pywrapfst.FarWriter", /*tp_name*/ + sizeof(struct __pyx_obj_9pywrapfst_FarWriter), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pywrapfst_FarWriter, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pywrapfst_9FarWriter_3__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_FarWriter, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n (No constructor.)\n\n FAR (\"Fst ARchive\") writer object.\n\n This class is used to write FSTs (of the same arc type) to a FAR on disk. To\n construct a FarWriter, use the `create` class method.\n\n Note that the data is not guaranteed to flush to disk until the FarWriter\n is garbage-collected. If a FarWriter has been assigned to only one variable,\n then calling `del` on that variable should decrement the object's reference\n count from 1 to 0, triggering a flush to disk on the next GC cycle.\n\n Attributes:\n arc_type: A string indicating the arc type.\n far_type: A string indicating the FAR type.\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pywrapfst_FarWriter, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_9pywrapfst_9FarWriter_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pywrapfst_FarWriter, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyMethodDef __pyx_methods[] = { + {"compact_symbol_table", (PyCFunction)__pyx_pw_9pywrapfst_9compact_symbol_table, METH_O, __pyx_doc_9pywrapfst_8compact_symbol_table}, + {"merge_symbol_table", (PyCFunction)__pyx_pw_9pywrapfst_11merge_symbol_table, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_10merge_symbol_table}, + {"_read", (PyCFunction)__pyx_pw_9pywrapfst_13_read, METH_O, 0}, + {"_read_from_string", (PyCFunction)__pyx_pw_9pywrapfst_15_read_from_string, METH_O, 0}, + {"arcmap", (PyCFunction)__pyx_pw_9pywrapfst_17arcmap, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_16arcmap}, + {"compose", (PyCFunction)__pyx_pw_9pywrapfst_19compose, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_18compose}, + {"convert", (PyCFunction)__pyx_pw_9pywrapfst_21convert, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_20convert}, + {"determinize", (PyCFunction)__pyx_pw_9pywrapfst_23determinize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_22determinize}, + {"difference", (PyCFunction)__pyx_pw_9pywrapfst_25difference, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_24difference}, + {"disambiguate", (PyCFunction)__pyx_pw_9pywrapfst_27disambiguate, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_26disambiguate}, + {"epsnormalize", (PyCFunction)__pyx_pw_9pywrapfst_29epsnormalize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_28epsnormalize}, + {"equal", (PyCFunction)__pyx_pw_9pywrapfst_31equal, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_30equal}, + {"equivalent", (PyCFunction)__pyx_pw_9pywrapfst_33equivalent, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_32equivalent}, + {"intersect", (PyCFunction)__pyx_pw_9pywrapfst_35intersect, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_34intersect}, + {"isomorphic", (PyCFunction)__pyx_pw_9pywrapfst_37isomorphic, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_36isomorphic}, + {"prune", (PyCFunction)__pyx_pw_9pywrapfst_39prune, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_38prune}, + {"push", (PyCFunction)__pyx_pw_9pywrapfst_41push, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_40push}, + {"randequivalent", (PyCFunction)__pyx_pw_9pywrapfst_43randequivalent, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_42randequivalent}, + {"randgen", (PyCFunction)__pyx_pw_9pywrapfst_45randgen, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_44randgen}, + {"replace", (PyCFunction)__pyx_pw_9pywrapfst_47replace, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_46replace}, + {"reverse", (PyCFunction)__pyx_pw_9pywrapfst_49reverse, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_48reverse}, + {"shortestpath", (PyCFunction)__pyx_pw_9pywrapfst_53shortestpath, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_52shortestpath}, + {"statemap", (PyCFunction)__pyx_pw_9pywrapfst_55statemap, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_54statemap}, + {"synchronize", (PyCFunction)__pyx_pw_9pywrapfst_57synchronize, METH_O, __pyx_doc_9pywrapfst_56synchronize}, + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_pywrapfst(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_pywrapfst}, + {0, NULL} +}; +#endif + +static struct PyModuleDef __pyx_moduledef = { + PyModuleDef_HEAD_INIT, + "pywrapfst", + __pyx_k_Python_interface_to_the_FST_scri, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_ACCEPTOR, __pyx_k_ACCEPTOR, sizeof(__pyx_k_ACCEPTOR), 0, 0, 1, 1}, + {&__pyx_n_s_ACCESSIBLE, __pyx_k_ACCESSIBLE, sizeof(__pyx_k_ACCESSIBLE), 0, 0, 1, 1}, + {&__pyx_n_s_ACYCLIC, __pyx_k_ACYCLIC, sizeof(__pyx_k_ACYCLIC), 0, 0, 1, 1}, + {&__pyx_n_s_ADD_ARC_PROPERTIES, __pyx_k_ADD_ARC_PROPERTIES, sizeof(__pyx_k_ADD_ARC_PROPERTIES), 0, 0, 1, 1}, + {&__pyx_n_s_ADD_STATE_PROPERTIES, __pyx_k_ADD_STATE_PROPERTIES, sizeof(__pyx_k_ADD_STATE_PROPERTIES), 0, 0, 1, 1}, + {&__pyx_n_s_ADD_SUPERFINAL_PROPERTIES, __pyx_k_ADD_SUPERFINAL_PROPERTIES, sizeof(__pyx_k_ADD_SUPERFINAL_PROPERTIES), 0, 0, 1, 1}, + {&__pyx_n_s_ARC_FLAGS, __pyx_k_ARC_FLAGS, sizeof(__pyx_k_ARC_FLAGS), 0, 0, 1, 1}, + {&__pyx_n_s_ARC_I_LABEL_VALUE, __pyx_k_ARC_I_LABEL_VALUE, sizeof(__pyx_k_ARC_I_LABEL_VALUE), 0, 0, 1, 1}, + {&__pyx_n_s_ARC_NEXT_STATE_VALUE, __pyx_k_ARC_NEXT_STATE_VALUE, sizeof(__pyx_k_ARC_NEXT_STATE_VALUE), 0, 0, 1, 1}, + {&__pyx_n_s_ARC_NO_CACHE, __pyx_k_ARC_NO_CACHE, sizeof(__pyx_k_ARC_NO_CACHE), 0, 0, 1, 1}, + {&__pyx_n_s_ARC_O_LABEL_VALUE, __pyx_k_ARC_O_LABEL_VALUE, sizeof(__pyx_k_ARC_O_LABEL_VALUE), 0, 0, 1, 1}, + {&__pyx_n_s_ARC_SORT_PROPERTIES, __pyx_k_ARC_SORT_PROPERTIES, sizeof(__pyx_k_ARC_SORT_PROPERTIES), 0, 0, 1, 1}, + {&__pyx_n_s_ARC_VALUE_FLAGS, __pyx_k_ARC_VALUE_FLAGS, sizeof(__pyx_k_ARC_VALUE_FLAGS), 0, 0, 1, 1}, + {&__pyx_n_s_ARC_WEIGHT_VALUE, __pyx_k_ARC_WEIGHT_VALUE, sizeof(__pyx_k_ARC_WEIGHT_VALUE), 0, 0, 1, 1}, + {&__pyx_kp_s_ArcIterator_at_0x_x, __pyx_k_ArcIterator_at_0x_x, sizeof(__pyx_k_ArcIterator_at_0x_x), 0, 0, 1, 0}, + {&__pyx_kp_s_Arc_at_0x_x, __pyx_k_Arc_at_0x_x, sizeof(__pyx_k_Arc_at_0x_x), 0, 0, 1, 0}, + {&__pyx_n_s_BINARY_PROPERTIES, __pyx_k_BINARY_PROPERTIES, sizeof(__pyx_k_BINARY_PROPERTIES), 0, 0, 1, 1}, + {&__pyx_n_s_COACCESSIBLE, __pyx_k_COACCESSIBLE, sizeof(__pyx_k_COACCESSIBLE), 0, 0, 1, 1}, + {&__pyx_n_s_COPY_PROPERTIES, __pyx_k_COPY_PROPERTIES, sizeof(__pyx_k_COPY_PROPERTIES), 0, 0, 1, 1}, + {&__pyx_n_s_CYCLIC, __pyx_k_CYCLIC, sizeof(__pyx_k_CYCLIC), 0, 0, 1, 1}, + {&__pyx_n_s_CalledProcessError, __pyx_k_CalledProcessError, sizeof(__pyx_k_CalledProcessError), 0, 0, 1, 1}, + {&__pyx_kp_s_Cannot_construct, __pyx_k_Cannot_construct, sizeof(__pyx_k_Cannot_construct), 0, 0, 1, 0}, + {&__pyx_kp_s_Cannot_encode_as_string_r, __pyx_k_Cannot_encode_as_string_r, sizeof(__pyx_k_Cannot_encode_as_string_r), 0, 0, 1, 0}, + {&__pyx_kp_s_Cannot_topsort_cyclic_FST, __pyx_k_Cannot_topsort_cyclic_FST, sizeof(__pyx_k_Cannot_topsort_cyclic_FST), 0, 0, 1, 0}, + {&__pyx_kp_s_Compilation_failed, __pyx_k_Compilation_failed, sizeof(__pyx_k_Compilation_failed), 0, 0, 1, 0}, + {&__pyx_kp_s_Conversion_to_r_failed, __pyx_k_Conversion_to_r_failed, sizeof(__pyx_k_Conversion_to_r_failed), 0, 0, 1, 0}, + {&__pyx_n_s_DELETE_ARC_PROPERTIES, __pyx_k_DELETE_ARC_PROPERTIES, sizeof(__pyx_k_DELETE_ARC_PROPERTIES), 0, 0, 1, 1}, + {&__pyx_n_s_DELETE_STATE_PROPERTIES, __pyx_k_DELETE_STATE_PROPERTIES, sizeof(__pyx_k_DELETE_STATE_PROPERTIES), 0, 0, 1, 1}, + {&__pyx_n_s_DOT_TSVG, __pyx_k_DOT_TSVG, sizeof(__pyx_k_DOT_TSVG), 0, 0, 1, 1}, + {&__pyx_n_s_ENCODE_FLAGS, __pyx_k_ENCODE_FLAGS, sizeof(__pyx_k_ENCODE_FLAGS), 0, 0, 1, 1}, + {&__pyx_n_s_ENCODE_LABELS, __pyx_k_ENCODE_LABELS, sizeof(__pyx_k_ENCODE_LABELS), 0, 0, 1, 1}, + {&__pyx_n_s_ENCODE_WEIGHTS, __pyx_k_ENCODE_WEIGHTS, sizeof(__pyx_k_ENCODE_WEIGHTS), 0, 0, 1, 1}, + {&__pyx_n_s_EPSILONS, __pyx_k_EPSILONS, sizeof(__pyx_k_EPSILONS), 0, 0, 1, 1}, + {&__pyx_n_s_ERROR, __pyx_k_ERROR, sizeof(__pyx_k_ERROR), 0, 0, 1, 1}, + {&__pyx_n_s_EXPANDED, __pyx_k_EXPANDED, sizeof(__pyx_k_EXPANDED), 0, 0, 1, 1}, + {&__pyx_n_s_EXTRINSIC_PROPERTIES, __pyx_k_EXTRINSIC_PROPERTIES, sizeof(__pyx_k_EXTRINSIC_PROPERTIES), 0, 0, 1, 1}, + {&__pyx_kp_s_EncodeMapper_at_0x_x, __pyx_k_EncodeMapper_at_0x_x, sizeof(__pyx_k_EncodeMapper_at_0x_x), 0, 0, 1, 0}, + {&__pyx_n_s_FST_PROPERTIES, __pyx_k_FST_PROPERTIES, sizeof(__pyx_k_FST_PROPERTIES), 0, 0, 1, 1}, + {&__pyx_kp_s_FarReader_at_0x_x, __pyx_k_FarReader_at_0x_x, sizeof(__pyx_k_FarReader_at_0x_x), 0, 0, 1, 0}, + {&__pyx_kp_s_FarWriter_at_0x_x, __pyx_k_FarWriter_at_0x_x, sizeof(__pyx_k_FarWriter_at_0x_x), 0, 0, 1, 0}, + {&__pyx_n_s_Fst, __pyx_k_Fst, sizeof(__pyx_k_Fst), 0, 0, 1, 1}, + {&__pyx_n_s_FstArgError, __pyx_k_FstArgError, sizeof(__pyx_k_FstArgError), 0, 0, 1, 1}, + {&__pyx_n_s_FstBadWeightError, __pyx_k_FstBadWeightError, sizeof(__pyx_k_FstBadWeightError), 0, 0, 1, 1}, + {&__pyx_n_s_FstDeletedConstructorError, __pyx_k_FstDeletedConstructorError, sizeof(__pyx_k_FstDeletedConstructorError), 0, 0, 1, 1}, + {&__pyx_n_s_FstError, __pyx_k_FstError, sizeof(__pyx_k_FstError), 0, 0, 1, 1}, + {&__pyx_n_s_FstIOError, __pyx_k_FstIOError, sizeof(__pyx_k_FstIOError), 0, 0, 1, 1}, + {&__pyx_n_s_FstIndexError, __pyx_k_FstIndexError, sizeof(__pyx_k_FstIndexError), 0, 0, 1, 1}, + {&__pyx_n_s_FstOpError, __pyx_k_FstOpError, sizeof(__pyx_k_FstOpError), 0, 0, 1, 1}, + {&__pyx_kp_s_Fst_SymbolTable_r_at_0x_x, __pyx_k_Fst_SymbolTable_r_at_0x_x, sizeof(__pyx_k_Fst_SymbolTable_r_at_0x_x), 0, 0, 1, 0}, + {&__pyx_n_s_Fst___new, __pyx_k_Fst___new, sizeof(__pyx_k_Fst___new), 0, 0, 1, 1}, + {&__pyx_kp_s_Fst_arc_type_standard_Construct, __pyx_k_Fst_arc_type_standard_Construct, sizeof(__pyx_k_Fst_arc_type_standard_Construct), 0, 0, 1, 0}, + {&__pyx_kp_s_Fst_at_0x_x, __pyx_k_Fst_at_0x_x, sizeof(__pyx_k_Fst_at_0x_x), 0, 0, 1, 0}, + {&__pyx_n_s_Fst_read, __pyx_k_Fst_read, sizeof(__pyx_k_Fst_read), 0, 0, 1, 1}, + {&__pyx_n_s_Fst_read_from_string, __pyx_k_Fst_read_from_string, sizeof(__pyx_k_Fst_read_from_string), 0, 0, 1, 1}, + {&__pyx_n_s_INITIAL_ACYCLIC, __pyx_k_INITIAL_ACYCLIC, sizeof(__pyx_k_INITIAL_ACYCLIC), 0, 0, 1, 1}, + {&__pyx_n_s_INITIAL_CYCLIC, __pyx_k_INITIAL_CYCLIC, sizeof(__pyx_k_INITIAL_CYCLIC), 0, 0, 1, 1}, + {&__pyx_n_s_INTRINSIC_PROPERTIES, __pyx_k_INTRINSIC_PROPERTIES, sizeof(__pyx_k_INTRINSIC_PROPERTIES), 0, 0, 1, 1}, + {&__pyx_n_s_IOError, __pyx_k_IOError, sizeof(__pyx_k_IOError), 0, 0, 1, 1}, + {&__pyx_n_s_I_DETERMINISTIC, __pyx_k_I_DETERMINISTIC, sizeof(__pyx_k_I_DETERMINISTIC), 0, 0, 1, 1}, + {&__pyx_n_s_I_EPSILONS, __pyx_k_I_EPSILONS, sizeof(__pyx_k_I_EPSILONS), 0, 0, 1, 1}, + {&__pyx_n_s_I_LABEL_INVARIANT_PROPERTIES, __pyx_k_I_LABEL_INVARIANT_PROPERTIES, sizeof(__pyx_k_I_LABEL_INVARIANT_PROPERTIES), 0, 0, 1, 1}, + {&__pyx_n_s_I_LABEL_SORTED, __pyx_k_I_LABEL_SORTED, sizeof(__pyx_k_I_LABEL_SORTED), 0, 0, 1, 1}, + {&__pyx_kp_s_Incompatible_or_invalid_arc_type, __pyx_k_Incompatible_or_invalid_arc_type, sizeof(__pyx_k_Incompatible_or_invalid_arc_type), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_or_invalid_weight, __pyx_k_Incompatible_or_invalid_weight, sizeof(__pyx_k_Incompatible_or_invalid_weight), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_or_invalid_weight_t, __pyx_k_Incompatible_or_invalid_weight_t, sizeof(__pyx_k_Incompatible_or_invalid_weight_t), 0, 0, 1, 0}, + {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1}, + {&__pyx_kp_s_Invalid_weight, __pyx_k_Invalid_weight, sizeof(__pyx_k_Invalid_weight), 0, 0, 1, 0}, + {&__pyx_n_s_KeyError, __pyx_k_KeyError, sizeof(__pyx_k_KeyError), 0, 0, 1, 1}, + {&__pyx_kp_s_Key_out_of_order, __pyx_k_Key_out_of_order, sizeof(__pyx_k_Key_out_of_order), 0, 0, 1, 0}, + {&__pyx_n_s_MUTABLE, __pyx_k_MUTABLE, sizeof(__pyx_k_MUTABLE), 0, 0, 1, 1}, + {&__pyx_kp_s_MutableArcIterator_at_0x_x, __pyx_k_MutableArcIterator_at_0x_x, sizeof(__pyx_k_MutableArcIterator_at_0x_x), 0, 0, 1, 0}, + {&__pyx_n_s_NEG_TRINARY_PROPERTIES, __pyx_k_NEG_TRINARY_PROPERTIES, sizeof(__pyx_k_NEG_TRINARY_PROPERTIES), 0, 0, 1, 1}, + {&__pyx_n_s_NON_I_DETERMINISTIC, __pyx_k_NON_I_DETERMINISTIC, sizeof(__pyx_k_NON_I_DETERMINISTIC), 0, 0, 1, 1}, + {&__pyx_n_s_NON_O_DETERMINISTIC, __pyx_k_NON_O_DETERMINISTIC, sizeof(__pyx_k_NON_O_DETERMINISTIC), 0, 0, 1, 1}, + {&__pyx_n_s_NOT_ACCEPTOR, __pyx_k_NOT_ACCEPTOR, sizeof(__pyx_k_NOT_ACCEPTOR), 0, 0, 1, 1}, + {&__pyx_n_s_NOT_ACCESSIBLE, __pyx_k_NOT_ACCESSIBLE, sizeof(__pyx_k_NOT_ACCESSIBLE), 0, 0, 1, 1}, + {&__pyx_n_s_NOT_COACCESSIBLE, __pyx_k_NOT_COACCESSIBLE, sizeof(__pyx_k_NOT_COACCESSIBLE), 0, 0, 1, 1}, + {&__pyx_n_s_NOT_I_LABEL_SORTED, __pyx_k_NOT_I_LABEL_SORTED, sizeof(__pyx_k_NOT_I_LABEL_SORTED), 0, 0, 1, 1}, + {&__pyx_n_s_NOT_O_LABEL_SORTED, __pyx_k_NOT_O_LABEL_SORTED, sizeof(__pyx_k_NOT_O_LABEL_SORTED), 0, 0, 1, 1}, + {&__pyx_n_s_NOT_STRING, __pyx_k_NOT_STRING, sizeof(__pyx_k_NOT_STRING), 0, 0, 1, 1}, + {&__pyx_n_s_NOT_TOP_SORTED, __pyx_k_NOT_TOP_SORTED, sizeof(__pyx_k_NOT_TOP_SORTED), 0, 0, 1, 1}, + {&__pyx_n_s_NO_EPSILONS, __pyx_k_NO_EPSILONS, sizeof(__pyx_k_NO_EPSILONS), 0, 0, 1, 1}, + {&__pyx_n_s_NO_I_EPSILONS, __pyx_k_NO_I_EPSILONS, sizeof(__pyx_k_NO_I_EPSILONS), 0, 0, 1, 1}, + {&__pyx_n_s_NO_LABEL, __pyx_k_NO_LABEL, sizeof(__pyx_k_NO_LABEL), 0, 0, 1, 1}, + {&__pyx_n_s_NO_O_EPSILONS, __pyx_k_NO_O_EPSILONS, sizeof(__pyx_k_NO_O_EPSILONS), 0, 0, 1, 1}, + {&__pyx_n_s_NO_STATE_ID, __pyx_k_NO_STATE_ID, sizeof(__pyx_k_NO_STATE_ID), 0, 0, 1, 1}, + {&__pyx_n_s_NO_SYMBOL, __pyx_k_NO_SYMBOL, sizeof(__pyx_k_NO_SYMBOL), 0, 0, 1, 1}, + {&__pyx_n_s_NULL_PROPERTIES, __pyx_k_NULL_PROPERTIES, sizeof(__pyx_k_NULL_PROPERTIES), 0, 0, 1, 1}, + {&__pyx_n_s_NoWeight, __pyx_k_NoWeight, sizeof(__pyx_k_NoWeight), 0, 0, 1, 1}, + {&__pyx_kp_s_No_new_SymbolTables_specified, __pyx_k_No_new_SymbolTables_specified, sizeof(__pyx_k_No_new_SymbolTables_specified), 0, 0, 1, 0}, + {&__pyx_kp_s_No_relabeling_pairs_specified, __pyx_k_No_relabeling_pairs_specified, sizeof(__pyx_k_No_relabeling_pairs_specified), 0, 0, 1, 0}, + {&__pyx_n_s_Number, __pyx_k_Number, sizeof(__pyx_k_Number), 0, 0, 1, 1}, + {&__pyx_n_s_O_DETERMINISTIC, __pyx_k_O_DETERMINISTIC, sizeof(__pyx_k_O_DETERMINISTIC), 0, 0, 1, 1}, + {&__pyx_n_s_O_EPSILONS, __pyx_k_O_EPSILONS, sizeof(__pyx_k_O_EPSILONS), 0, 0, 1, 1}, + {&__pyx_n_s_O_LABEL_INVARIANT_PROPERTIES, __pyx_k_O_LABEL_INVARIANT_PROPERTIES, sizeof(__pyx_k_O_LABEL_INVARIANT_PROPERTIES), 0, 0, 1, 1}, + {&__pyx_n_s_O_LABEL_SORTED, __pyx_k_O_LABEL_SORTED, sizeof(__pyx_k_O_LABEL_SORTED), 0, 0, 1, 1}, + {&__pyx_n_s_One, __pyx_k_One, sizeof(__pyx_k_One), 0, 0, 1, 1}, + {&__pyx_kp_s_Open_failed_r, __pyx_k_Open_failed_r, sizeof(__pyx_k_Open_failed_r), 0, 0, 1, 0}, + {&__pyx_kp_s_Operation_failed, __pyx_k_Operation_failed, sizeof(__pyx_k_Operation_failed), 0, 0, 1, 0}, + {&__pyx_n_s_PIPE, __pyx_k_PIPE, sizeof(__pyx_k_PIPE), 0, 0, 1, 1}, + {&__pyx_n_s_POS_TRINARY_PROPERTIES, __pyx_k_POS_TRINARY_PROPERTIES, sizeof(__pyx_k_POS_TRINARY_PROPERTIES), 0, 0, 1, 1}, + {&__pyx_n_s_Popen, __pyx_k_Popen, sizeof(__pyx_k_Popen), 0, 0, 1, 1}, + {&__pyx_n_s_RM_SUPERFINAL_PROPERTIES, __pyx_k_RM_SUPERFINAL_PROPERTIES, sizeof(__pyx_k_RM_SUPERFINAL_PROPERTIES), 0, 0, 1, 1}, + {&__pyx_kp_s_Read_failed_r, __pyx_k_Read_failed_r, sizeof(__pyx_k_Read_failed_r), 0, 0, 1, 0}, + {&__pyx_kp_s_Read_failed_string, __pyx_k_Read_failed_string, sizeof(__pyx_k_Read_failed_string), 0, 0, 1, 0}, + {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, + {&__pyx_n_s_SET_ARC_PROPERTIES, __pyx_k_SET_ARC_PROPERTIES, sizeof(__pyx_k_SET_ARC_PROPERTIES), 0, 0, 1, 1}, + {&__pyx_n_s_SET_FINAL_PROPERTIES, __pyx_k_SET_FINAL_PROPERTIES, sizeof(__pyx_k_SET_FINAL_PROPERTIES), 0, 0, 1, 1}, + {&__pyx_n_s_SET_START_PROPERTIES, __pyx_k_SET_START_PROPERTIES, sizeof(__pyx_k_SET_START_PROPERTIES), 0, 0, 1, 1}, + {&__pyx_n_s_STATE_SORT_PROPERTIES, __pyx_k_STATE_SORT_PROPERTIES, sizeof(__pyx_k_STATE_SORT_PROPERTIES), 0, 0, 1, 1}, + {&__pyx_n_s_STRING, __pyx_k_STRING, sizeof(__pyx_k_STRING), 0, 0, 1, 1}, + {&__pyx_kp_s_StateIterator_at_0x_x, __pyx_k_StateIterator_at_0x_x, sizeof(__pyx_k_StateIterator_at_0x_x), 0, 0, 1, 0}, + {&__pyx_kp_s_State_index_out_of_range, __pyx_k_State_index_out_of_range, sizeof(__pyx_k_State_index_out_of_range), 0, 0, 1, 0}, + {&__pyx_n_s_StopIteration, __pyx_k_StopIteration, sizeof(__pyx_k_StopIteration), 0, 0, 1, 1}, + {&__pyx_kp_s_SymbolTableIterator_at_0x_x, __pyx_k_SymbolTableIterator_at_0x_x, sizeof(__pyx_k_SymbolTableIterator_at_0x_x), 0, 0, 1, 0}, + {&__pyx_kp_s_SymbolTable_r_at_0x_x, __pyx_k_SymbolTable_r_at_0x_x, sizeof(__pyx_k_SymbolTable_r_at_0x_x), 0, 0, 1, 0}, + {&__pyx_n_s_TOP_SORTED, __pyx_k_TOP_SORTED, sizeof(__pyx_k_TOP_SORTED), 0, 0, 1, 1}, + {&__pyx_n_s_TRINARY_PROPERTIES, __pyx_k_TRINARY_PROPERTIES, sizeof(__pyx_k_TRINARY_PROPERTIES), 0, 0, 1, 1}, + {&__pyx_kp_s_Tsvg, __pyx_k_Tsvg, sizeof(__pyx_k_Tsvg), 0, 0, 1, 0}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_n_s_UNWEIGHTED, __pyx_k_UNWEIGHTED, sizeof(__pyx_k_UNWEIGHTED), 0, 0, 1, 1}, + {&__pyx_n_s_UNWEIGHTED_CYCLES, __pyx_k_UNWEIGHTED_CYCLES, sizeof(__pyx_k_UNWEIGHTED_CYCLES), 0, 0, 1, 1}, + {&__pyx_kp_s_Unknown_arc_type_r, __pyx_k_Unknown_arc_type_r, sizeof(__pyx_k_Unknown_arc_type_r), 0, 0, 1, 0}, + {&__pyx_kp_s_Unknown_compose_filter_type_r, __pyx_k_Unknown_compose_filter_type_r, sizeof(__pyx_k_Unknown_compose_filter_type_r), 0, 0, 1, 0}, + {&__pyx_kp_s_Unknown_determinization_type_r, __pyx_k_Unknown_determinization_type_r, sizeof(__pyx_k_Unknown_determinization_type_r), 0, 0, 1, 0}, + {&__pyx_kp_s_Unknown_map_type_r, __pyx_k_Unknown_map_type_r, sizeof(__pyx_k_Unknown_map_type_r), 0, 0, 1, 0}, + {&__pyx_kp_s_Unknown_queue_type_r, __pyx_k_Unknown_queue_type_r, sizeof(__pyx_k_Unknown_queue_type_r), 0, 0, 1, 0}, + {&__pyx_kp_s_Unknown_random_arc_selection_typ, __pyx_k_Unknown_random_arc_selection_typ, sizeof(__pyx_k_Unknown_random_arc_selection_typ), 0, 0, 1, 0}, + {&__pyx_kp_s_Unknown_replace_label_type_r, __pyx_k_Unknown_replace_label_type_r, sizeof(__pyx_k_Unknown_replace_label_type_r), 0, 0, 1, 0}, + {&__pyx_kp_s_Unknown_sort_type_r, __pyx_k_Unknown_sort_type_r, sizeof(__pyx_k_Unknown_sort_type_r), 0, 0, 1, 0}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_WEIGHTED, __pyx_k_WEIGHTED, sizeof(__pyx_k_WEIGHTED), 0, 0, 1, 1}, + {&__pyx_n_s_WEIGHTED_CYCLES, __pyx_k_WEIGHTED_CYCLES, sizeof(__pyx_k_WEIGHTED_CYCLES), 0, 0, 1, 1}, + {&__pyx_n_s_WEIGHT_INVARIANT_PROPERTIES, __pyx_k_WEIGHT_INVARIANT_PROPERTIES, sizeof(__pyx_k_WEIGHT_INVARIANT_PROPERTIES), 0, 0, 1, 1}, + {&__pyx_kp_s_Weight_at_0x_x, __pyx_k_Weight_at_0x_x, sizeof(__pyx_k_Weight_at_0x_x), 0, 0, 1, 0}, + {&__pyx_kp_s_Weight_type_not_found, __pyx_k_Weight_type_not_found, sizeof(__pyx_k_Weight_type_not_found), 0, 0, 1, 0}, + {&__pyx_kp_s_Write_failed_r, __pyx_k_Write_failed_r, sizeof(__pyx_k_Write_failed_r), 0, 0, 1, 0}, + {&__pyx_kp_s_Write_to_string_failed, __pyx_k_Write_to_string_failed, sizeof(__pyx_k_Write_to_string_failed), 0, 0, 1, 0}, + {&__pyx_n_s_Zero, __pyx_k_Zero, sizeof(__pyx_k_Zero), 0, 0, 1, 1}, + {&__pyx_kp_b__24, __pyx_k__24, sizeof(__pyx_k__24), 0, 0, 0, 0}, + {&__pyx_n_s_acceptor, __pyx_k_acceptor, sizeof(__pyx_k_acceptor), 0, 0, 1, 1}, + {&__pyx_n_s_add, __pyx_k_add, sizeof(__pyx_k_add), 0, 0, 1, 1}, + {&__pyx_n_s_add_state, __pyx_k_add_state, sizeof(__pyx_k_add_state), 0, 0, 1, 1}, + {&__pyx_n_s_add_symbol, __pyx_k_add_symbol, sizeof(__pyx_k_add_symbol), 0, 0, 1, 1}, + {&__pyx_n_s_add_table, __pyx_k_add_table, sizeof(__pyx_k_add_table), 0, 0, 1, 1}, + {&__pyx_n_s_allow_negative_labels, __pyx_k_allow_negative_labels, sizeof(__pyx_k_allow_negative_labels), 0, 0, 1, 1}, + {&__pyx_n_s_allow_nondet, __pyx_k_allow_nondet, sizeof(__pyx_k_allow_nondet), 0, 0, 1, 1}, + {&__pyx_n_s_arc, __pyx_k_arc, sizeof(__pyx_k_arc), 0, 0, 1, 1}, + {&__pyx_n_s_arc_type, __pyx_k_arc_type, sizeof(__pyx_k_arc_type), 0, 0, 1, 1}, + {&__pyx_n_s_arcs, __pyx_k_arcs, sizeof(__pyx_k_arcs), 0, 0, 1, 1}, + {&__pyx_n_s_atexit, __pyx_k_atexit, sizeof(__pyx_k_atexit), 0, 0, 1, 1}, + {&__pyx_n_s_attach_new_isymbols, __pyx_k_attach_new_isymbols, sizeof(__pyx_k_attach_new_isymbols), 0, 0, 1, 1}, + {&__pyx_n_s_attach_new_osymbols, __pyx_k_attach_new_osymbols, sizeof(__pyx_k_attach_new_osymbols), 0, 0, 1, 1}, + {&__pyx_n_b_auto, __pyx_k_auto, sizeof(__pyx_k_auto), 0, 0, 0, 1}, + {&__pyx_n_s_available_key, __pyx_k_available_key, sizeof(__pyx_k_available_key), 0, 0, 1, 1}, + {&__pyx_n_s_call_arc_labeling, __pyx_k_call_arc_labeling, sizeof(__pyx_k_call_arc_labeling), 0, 0, 1, 1}, + {&__pyx_n_s_checksum, __pyx_k_checksum, sizeof(__pyx_k_checksum), 0, 0, 1, 1}, + {&__pyx_n_s_class, __pyx_k_class, sizeof(__pyx_k_class), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_closure_plus, __pyx_k_closure_plus, sizeof(__pyx_k_closure_plus), 0, 0, 1, 1}, + {&__pyx_n_s_cls, __pyx_k_cls, sizeof(__pyx_k_cls), 0, 0, 1, 1}, + {&__pyx_n_s_communicate, __pyx_k_communicate, sizeof(__pyx_k_communicate), 0, 0, 1, 1}, + {&__pyx_n_s_compile, __pyx_k_compile, sizeof(__pyx_k_compile), 0, 0, 1, 1}, + {&__pyx_n_s_compose_filter, __pyx_k_compose_filter, sizeof(__pyx_k_compose_filter), 0, 0, 1, 1}, + {&__pyx_n_s_connect, __pyx_k_connect, sizeof(__pyx_k_connect), 0, 0, 1, 1}, + {&__pyx_kp_s_const_EncodeMapper_SymbolTable, __pyx_k_const_EncodeMapper_SymbolTable, sizeof(__pyx_k_const_EncodeMapper_SymbolTable), 0, 0, 1, 0}, + {&__pyx_kp_s_const_Fst_SymbolTable_r_at_0x_x, __pyx_k_const_Fst_SymbolTable_r_at_0x_x, sizeof(__pyx_k_const_Fst_SymbolTable_r_at_0x_x), 0, 0, 1, 0}, + {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1}, + {&__pyx_n_s_create, __pyx_k_create, sizeof(__pyx_k_create), 0, 0, 1, 1}, + {&__pyx_n_s_decode, __pyx_k_decode, sizeof(__pyx_k_decode), 0, 0, 1, 1}, + {&__pyx_n_b_default, __pyx_k_default, sizeof(__pyx_k_default), 0, 0, 0, 1}, + {&__pyx_n_s_delta, __pyx_k_delta, sizeof(__pyx_k_delta), 0, 0, 1, 1}, + {&__pyx_n_s_det_type, __pyx_k_det_type, sizeof(__pyx_k_det_type), 0, 0, 1, 1}, + {&__pyx_n_s_distance, __pyx_k_distance, sizeof(__pyx_k_distance), 0, 0, 1, 1}, + {&__pyx_n_s_divide, __pyx_k_divide, sizeof(__pyx_k_divide), 0, 0, 1, 1}, + {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1}, + {&__pyx_n_s_done, __pyx_k_done, sizeof(__pyx_k_done), 0, 0, 1, 1}, + {&__pyx_n_s_dot, __pyx_k_dot, sizeof(__pyx_k_dot), 0, 0, 1, 1}, + {&__pyx_n_s_draw, __pyx_k_draw, sizeof(__pyx_k_draw), 0, 0, 1, 1}, + {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1}, + {&__pyx_n_s_encode_labels, __pyx_k_encode_labels, sizeof(__pyx_k_encode_labels), 0, 0, 1, 1}, + {&__pyx_n_s_encode_weights, __pyx_k_encode_weights, sizeof(__pyx_k_encode_weights), 0, 0, 1, 1}, + {&__pyx_n_s_eps_norm_output, __pyx_k_eps_norm_output, sizeof(__pyx_k_eps_norm_output), 0, 0, 1, 1}, + {&__pyx_n_s_epsilon_on_replace, __pyx_k_epsilon_on_replace, sizeof(__pyx_k_epsilon_on_replace), 0, 0, 1, 1}, + {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1}, + {&__pyx_n_s_far_type, __pyx_k_far_type, sizeof(__pyx_k_far_type), 0, 0, 1, 1}, + {&__pyx_n_s_filename, __pyx_k_filename, sizeof(__pyx_k_filename), 0, 0, 1, 1}, + {&__pyx_n_s_final, __pyx_k_final, sizeof(__pyx_k_final), 0, 0, 1, 1}, + {&__pyx_n_s_find, __pyx_k_find, sizeof(__pyx_k_find), 0, 0, 1, 1}, + {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1}, + {&__pyx_n_s_float_format, __pyx_k_float_format, sizeof(__pyx_k_float_format), 0, 0, 1, 1}, + {&__pyx_n_s_fontsize, __pyx_k_fontsize, sizeof(__pyx_k_fontsize), 0, 0, 1, 1}, + {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1}, + {&__pyx_n_s_fst_error_fatal_old, __pyx_k_fst_error_fatal_old, sizeof(__pyx_k_fst_error_fatal_old), 0, 0, 1, 1}, + {&__pyx_n_s_fst_type, __pyx_k_fst_type, sizeof(__pyx_k_fst_type), 0, 0, 1, 1}, + {&__pyx_n_b_functional, __pyx_k_functional, sizeof(__pyx_k_functional), 0, 0, 0, 1}, + {&__pyx_n_b_g, __pyx_k_g, sizeof(__pyx_k_g), 0, 0, 0, 1}, + {&__pyx_n_s_get_fst, __pyx_k_get_fst, sizeof(__pyx_k_get_fst), 0, 0, 1, 1}, + {&__pyx_n_s_get_key, __pyx_k_get_key, sizeof(__pyx_k_get_key), 0, 0, 1, 1}, + {&__pyx_n_s_get_nth_key, __pyx_k_get_nth_key, sizeof(__pyx_k_get_nth_key), 0, 0, 1, 1}, + {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, + {&__pyx_n_s_height, __pyx_k_height, sizeof(__pyx_k_height), 0, 0, 1, 1}, + {&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 0, 0, 1, 1}, + {&__pyx_n_b_identity, __pyx_k_identity, sizeof(__pyx_k_identity), 0, 0, 0, 1}, + {&__pyx_n_s_ifst, __pyx_k_ifst, sizeof(__pyx_k_ifst), 0, 0, 1, 1}, + {&__pyx_n_s_ifst1, __pyx_k_ifst1, sizeof(__pyx_k_ifst1), 0, 0, 1, 1}, + {&__pyx_n_s_ifst2, __pyx_k_ifst2, sizeof(__pyx_k_ifst2), 0, 0, 1, 1}, + {&__pyx_n_b_ilabel, __pyx_k_ilabel, sizeof(__pyx_k_ilabel), 0, 0, 0, 1}, + {&__pyx_n_s_ilabel, __pyx_k_ilabel, sizeof(__pyx_k_ilabel), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_increment_subsequential_label, __pyx_k_increment_subsequential_label, sizeof(__pyx_k_increment_subsequential_label), 0, 0, 1, 1}, + {&__pyx_n_b_input, __pyx_k_input, sizeof(__pyx_k_input), 0, 0, 0, 1}, + {&__pyx_n_s_input_symbols, __pyx_k_input_symbols, sizeof(__pyx_k_input_symbols), 0, 0, 1, 1}, + {&__pyx_n_s_input_table, __pyx_k_input_table, sizeof(__pyx_k_input_table), 0, 0, 1, 1}, + {&__pyx_n_s_ipairs, __pyx_k_ipairs, sizeof(__pyx_k_ipairs), 0, 0, 1, 1}, + {&__pyx_n_s_isymbols, __pyx_k_isymbols, sizeof(__pyx_k_isymbols), 0, 0, 1, 1}, + {&__pyx_n_s_kNoSymbol, __pyx_k_kNoSymbol, sizeof(__pyx_k_kNoSymbol), 0, 0, 1, 1}, + {&__pyx_n_s_keep_isymbols, __pyx_k_keep_isymbols, sizeof(__pyx_k_keep_isymbols), 0, 0, 1, 1}, + {&__pyx_n_s_keep_osymbols, __pyx_k_keep_osymbols, sizeof(__pyx_k_keep_osymbols), 0, 0, 1, 1}, + {&__pyx_n_s_keep_state_numbering, __pyx_k_keep_state_numbering, sizeof(__pyx_k_keep_state_numbering), 0, 0, 1, 1}, + {&__pyx_n_s_key, __pyx_k_key, sizeof(__pyx_k_key), 0, 0, 1, 1}, + {&__pyx_n_s_labeled_checksum, __pyx_k_labeled_checksum, sizeof(__pyx_k_labeled_checksum), 0, 0, 1, 1}, + {&__pyx_n_s_lhs, __pyx_k_lhs, sizeof(__pyx_k_lhs), 0, 0, 1, 1}, + {&__pyx_n_s_logging, __pyx_k_logging, sizeof(__pyx_k_logging), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_map_type, __pyx_k_map_type, sizeof(__pyx_k_map_type), 0, 0, 1, 1}, + {&__pyx_n_s_mask, __pyx_k_mask, sizeof(__pyx_k_mask), 0, 0, 1, 1}, + {&__pyx_n_s_max_length, __pyx_k_max_length, sizeof(__pyx_k_max_length), 0, 0, 1, 1}, + {&__pyx_n_s_member, __pyx_k_member, sizeof(__pyx_k_member), 0, 0, 1, 1}, + {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1}, + {&__pyx_n_s_missing_sym, __pyx_k_missing_sym, sizeof(__pyx_k_missing_sym), 0, 0, 1, 1}, + {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1}, + {&__pyx_n_s_mutable_arcs, __pyx_k_mutable_arcs, sizeof(__pyx_k_mutable_arcs), 0, 0, 1, 1}, + {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, + {&__pyx_n_b_neither, __pyx_k_neither, sizeof(__pyx_k_neither), 0, 0, 0, 1}, + {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, + {&__pyx_n_s_new_isymbols, __pyx_k_new_isymbols, sizeof(__pyx_k_new_isymbols), 0, 0, 1, 1}, + {&__pyx_n_s_new_osymbols, __pyx_k_new_osymbols, sizeof(__pyx_k_new_osymbols), 0, 0, 1, 1}, + {&__pyx_n_s_next, __pyx_k_next, sizeof(__pyx_k_next), 0, 0, 1, 1}, + {&__pyx_n_s_nextstate, __pyx_k_nextstate, sizeof(__pyx_k_nextstate), 0, 0, 1, 1}, + {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, + {&__pyx_n_s_nodesep, __pyx_k_nodesep, sizeof(__pyx_k_nodesep), 0, 0, 1, 1}, + {&__pyx_n_s_npath, __pyx_k_npath, sizeof(__pyx_k_npath), 0, 0, 1, 1}, + {&__pyx_n_s_nshortest, __pyx_k_nshortest, sizeof(__pyx_k_nshortest), 0, 0, 1, 1}, + {&__pyx_n_s_nstate, __pyx_k_nstate, sizeof(__pyx_k_nstate), 0, 0, 1, 1}, + {&__pyx_n_s_num_arcs, __pyx_k_num_arcs, sizeof(__pyx_k_num_arcs), 0, 0, 1, 1}, + {&__pyx_n_s_num_input_epsilons, __pyx_k_num_input_epsilons, sizeof(__pyx_k_num_input_epsilons), 0, 0, 1, 1}, + {&__pyx_n_s_num_output_epsilons, __pyx_k_num_output_epsilons, sizeof(__pyx_k_num_output_epsilons), 0, 0, 1, 1}, + {&__pyx_n_s_num_states, __pyx_k_num_states, sizeof(__pyx_k_num_states), 0, 0, 1, 1}, + {&__pyx_n_s_num_symbols, __pyx_k_num_symbols, sizeof(__pyx_k_num_symbols), 0, 0, 1, 1}, + {&__pyx_n_s_numbers, __pyx_k_numbers, sizeof(__pyx_k_numbers), 0, 0, 1, 1}, + {&__pyx_n_s_object, __pyx_k_object, sizeof(__pyx_k_object), 0, 0, 1, 1}, + {&__pyx_n_s_olabel, __pyx_k_olabel, sizeof(__pyx_k_olabel), 0, 0, 1, 1}, + {&__pyx_n_s_old_isymbols, __pyx_k_old_isymbols, sizeof(__pyx_k_old_isymbols), 0, 0, 1, 1}, + {&__pyx_n_s_old_osymbols, __pyx_k_old_osymbols, sizeof(__pyx_k_old_osymbols), 0, 0, 1, 1}, + {&__pyx_n_s_opairs, __pyx_k_opairs, sizeof(__pyx_k_opairs), 0, 0, 1, 1}, + {&__pyx_n_s_open, __pyx_k_open, sizeof(__pyx_k_open), 0, 0, 1, 1}, + {&__pyx_n_s_osymbols, __pyx_k_osymbols, sizeof(__pyx_k_osymbols), 0, 0, 1, 1}, + {&__pyx_n_s_output_symbols, __pyx_k_output_symbols, sizeof(__pyx_k_output_symbols), 0, 0, 1, 1}, + {&__pyx_n_s_pairs, __pyx_k_pairs, sizeof(__pyx_k_pairs), 0, 0, 1, 1}, + {&__pyx_n_s_plus, __pyx_k_plus, sizeof(__pyx_k_plus), 0, 0, 1, 1}, + {&__pyx_n_s_portrait, __pyx_k_portrait, sizeof(__pyx_k_portrait), 0, 0, 1, 1}, + {&__pyx_n_s_position, __pyx_k_position, sizeof(__pyx_k_position), 0, 0, 1, 1}, + {&__pyx_n_s_potentials, __pyx_k_potentials, sizeof(__pyx_k_potentials), 0, 0, 1, 1}, + {&__pyx_n_s_power, __pyx_k_power, sizeof(__pyx_k_power), 0, 0, 1, 1}, + {&__pyx_n_s_precision, __pyx_k_precision, sizeof(__pyx_k_precision), 0, 0, 1, 1}, + {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1}, + {&__pyx_n_s_project_output, __pyx_k_project_output, sizeof(__pyx_k_project_output), 0, 0, 1, 1}, + {&__pyx_n_s_properties, __pyx_k_properties, sizeof(__pyx_k_properties), 0, 0, 1, 1}, + {&__pyx_n_s_props, __pyx_k_props, sizeof(__pyx_k_props), 0, 0, 1, 1}, + {&__pyx_n_s_push_labels, __pyx_k_push_labels, sizeof(__pyx_k_push_labels), 0, 0, 1, 1}, + {&__pyx_n_s_push_weights, __pyx_k_push_weights, sizeof(__pyx_k_push_weights), 0, 0, 1, 1}, + {&__pyx_kp_b_pywrapfst, __pyx_k_pywrapfst, sizeof(__pyx_k_pywrapfst), 0, 0, 0, 0}, + {&__pyx_n_s_pywrapfst_2, __pyx_k_pywrapfst_2, sizeof(__pyx_k_pywrapfst_2), 0, 0, 1, 1}, + {&__pyx_kp_s_pywrapfst_pyx, __pyx_k_pywrapfst_pyx, sizeof(__pyx_k_pywrapfst_pyx), 0, 0, 1, 0}, + {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, + {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1}, + {&__pyx_n_s_queue_type, __pyx_k_queue_type, sizeof(__pyx_k_queue_type), 0, 0, 1, 1}, + {&__pyx_n_s_ranksep, __pyx_k_ranksep, sizeof(__pyx_k_ranksep), 0, 0, 1, 1}, + {&__pyx_n_s_read, __pyx_k_read, sizeof(__pyx_k_read), 0, 0, 1, 1}, + {&__pyx_n_s_read_from_string, __pyx_k_read_from_string, sizeof(__pyx_k_read_from_string), 0, 0, 1, 1}, + {&__pyx_n_s_read_from_string_2, __pyx_k_read_from_string_2, sizeof(__pyx_k_read_from_string_2), 0, 0, 1, 1}, + {&__pyx_n_s_read_fst, __pyx_k_read_fst, sizeof(__pyx_k_read_fst), 0, 0, 1, 1}, + {&__pyx_n_s_read_text, __pyx_k_read_text, sizeof(__pyx_k_read_text), 0, 0, 1, 1}, + {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, + {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, + {&__pyx_n_s_register, __pyx_k_register, sizeof(__pyx_k_register), 0, 0, 1, 1}, + {&__pyx_n_s_remove_common_affix, __pyx_k_remove_common_affix, sizeof(__pyx_k_remove_common_affix), 0, 0, 1, 1}, + {&__pyx_n_s_remove_total_weight, __pyx_k_remove_total_weight, sizeof(__pyx_k_remove_total_weight), 0, 0, 1, 1}, + {&__pyx_n_b_repr_svg, __pyx_k_repr_svg, sizeof(__pyx_k_repr_svg), 0, 0, 0, 1}, + {&__pyx_n_s_require_superinitial, __pyx_k_require_superinitial, sizeof(__pyx_k_require_superinitial), 0, 0, 1, 1}, + {&__pyx_n_s_reset, __pyx_k_reset, sizeof(__pyx_k_reset), 0, 0, 1, 1}, + {&__pyx_n_s_reset_fst_error_fatal, __pyx_k_reset_fst_error_fatal, sizeof(__pyx_k_reset_fst_error_fatal), 0, 0, 1, 1}, + {&__pyx_n_s_result, __pyx_k_result, sizeof(__pyx_k_result), 0, 0, 1, 1}, + {&__pyx_n_s_return_arc_labeling, __pyx_k_return_arc_labeling, sizeof(__pyx_k_return_arc_labeling), 0, 0, 1, 1}, + {&__pyx_n_s_return_label, __pyx_k_return_label, sizeof(__pyx_k_return_label), 0, 0, 1, 1}, + {&__pyx_n_s_returncode, __pyx_k_returncode, sizeof(__pyx_k_returncode), 0, 0, 1, 1}, + {&__pyx_n_s_reverse, __pyx_k_reverse, sizeof(__pyx_k_reverse), 0, 0, 1, 1}, + {&__pyx_n_s_rhs, __pyx_k_rhs, sizeof(__pyx_k_rhs), 0, 0, 1, 1}, + {&__pyx_n_s_seed, __pyx_k_seed, sizeof(__pyx_k_seed), 0, 0, 1, 1}, + {&__pyx_n_s_seek, __pyx_k_seek, sizeof(__pyx_k_seek), 0, 0, 1, 1}, + {&__pyx_n_s_select, __pyx_k_select, sizeof(__pyx_k_select), 0, 0, 1, 1}, + {&__pyx_kp_s_self__aiter_self__fst_cannot_be, __pyx_k_self__aiter_self__fst_cannot_be, sizeof(__pyx_k_self__aiter_self__fst_cannot_be), 0, 0, 1, 0}, + {&__pyx_kp_s_self__aiter_self__mfst_cannot_be, __pyx_k_self__aiter_self__mfst_cannot_be, sizeof(__pyx_k_self__aiter_self__mfst_cannot_be), 0, 0, 1, 0}, + {&__pyx_kp_s_self__arc_cannot_be_converted_to, __pyx_k_self__arc_cannot_be_converted_to, sizeof(__pyx_k_self__arc_cannot_be_converted_to), 0, 0, 1, 0}, + {&__pyx_kp_s_self__encoder_cannot_be_converte, __pyx_k_self__encoder_cannot_be_converte, sizeof(__pyx_k_self__encoder_cannot_be_converte), 0, 0, 1, 0}, + {&__pyx_kp_s_self__encoder_self__table_cannot, __pyx_k_self__encoder_self__table_cannot, sizeof(__pyx_k_self__encoder_self__table_cannot), 0, 0, 1, 0}, + {&__pyx_kp_s_self__fst_self__siter_cannot_be, __pyx_k_self__fst_self__siter_cannot_be, sizeof(__pyx_k_self__fst_self__siter_cannot_be), 0, 0, 1, 0}, + {&__pyx_kp_s_self__fst_self__table_cannot_be, __pyx_k_self__fst_self__table_cannot_be, sizeof(__pyx_k_self__fst_self__table_cannot_be), 0, 0, 1, 0}, + {&__pyx_kp_s_self__mfst_self__table_cannot_be, __pyx_k_self__mfst_self__table_cannot_be, sizeof(__pyx_k_self__mfst_self__table_cannot_be), 0, 0, 1, 0}, + {&__pyx_kp_s_self__reader_cannot_be_converted, __pyx_k_self__reader_cannot_be_converted, sizeof(__pyx_k_self__reader_cannot_be_converted), 0, 0, 1, 0}, + {&__pyx_kp_s_self__siter_self__table_cannot_b, __pyx_k_self__siter_self__table_cannot_b, sizeof(__pyx_k_self__siter_self__table_cannot_b), 0, 0, 1, 0}, + {&__pyx_kp_s_self__smart_table_self__table_ca, __pyx_k_self__smart_table_self__table_ca, sizeof(__pyx_k_self__smart_table_self__table_ca), 0, 0, 1, 0}, + {&__pyx_kp_s_self__table_cannot_be_converted, __pyx_k_self__table_cannot_be_converted, sizeof(__pyx_k_self__table_cannot_be_converted), 0, 0, 1, 0}, + {&__pyx_kp_s_self__weight_cannot_be_converted, __pyx_k_self__weight_cannot_be_converted, sizeof(__pyx_k_self__weight_cannot_be_converted), 0, 0, 1, 0}, + {&__pyx_kp_s_self__writer_cannot_be_converted, __pyx_k_self__writer_cannot_be_converted, sizeof(__pyx_k_self__writer_cannot_be_converted), 0, 0, 1, 0}, + {&__pyx_n_s_set_flags, __pyx_k_set_flags, sizeof(__pyx_k_set_flags), 0, 0, 1, 1}, + {&__pyx_n_s_set_input_symbols, __pyx_k_set_input_symbols, sizeof(__pyx_k_set_input_symbols), 0, 0, 1, 1}, + {&__pyx_n_s_set_name, __pyx_k_set_name, sizeof(__pyx_k_set_name), 0, 0, 1, 1}, + {&__pyx_n_s_set_output_symbols, __pyx_k_set_output_symbols, sizeof(__pyx_k_set_output_symbols), 0, 0, 1, 1}, + {&__pyx_n_s_set_value, __pyx_k_set_value, sizeof(__pyx_k_set_value), 0, 0, 1, 1}, + {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, + {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_shortestdistance, __pyx_k_shortestdistance, sizeof(__pyx_k_shortestdistance), 0, 0, 1, 1}, + {&__pyx_n_s_show_weight_one, __pyx_k_show_weight_one, sizeof(__pyx_k_show_weight_one), 0, 0, 1, 1}, + {&__pyx_n_s_sort_type, __pyx_k_sort_type, sizeof(__pyx_k_sort_type), 0, 0, 1, 1}, + {&__pyx_n_s_ssymbols, __pyx_k_ssymbols, sizeof(__pyx_k_ssymbols), 0, 0, 1, 1}, + {&__pyx_n_b_standard, __pyx_k_standard, sizeof(__pyx_k_standard), 0, 0, 0, 1}, + {&__pyx_n_s_start, __pyx_k_start, sizeof(__pyx_k_start), 0, 0, 1, 1}, + {&__pyx_n_s_state, __pyx_k_state, sizeof(__pyx_k_state), 0, 0, 1, 1}, + {&__pyx_n_s_states, __pyx_k_states, sizeof(__pyx_k_states), 0, 0, 1, 1}, + {&__pyx_n_s_staticmethod, __pyx_k_staticmethod, sizeof(__pyx_k_staticmethod), 0, 0, 1, 1}, + {&__pyx_n_s_stderr, __pyx_k_stderr, sizeof(__pyx_k_stderr), 0, 0, 1, 1}, + {&__pyx_n_s_stdin, __pyx_k_stdin, sizeof(__pyx_k_stdin), 0, 0, 1, 1}, + {&__pyx_n_s_stdout, __pyx_k_stdout, sizeof(__pyx_k_stdout), 0, 0, 1, 1}, + {&__pyx_n_s_subprocess, __pyx_k_subprocess, sizeof(__pyx_k_subprocess), 0, 0, 1, 1}, + {&__pyx_n_s_subsequential_label, __pyx_k_subsequential_label, sizeof(__pyx_k_subsequential_label), 0, 0, 1, 1}, + {&__pyx_n_s_symbol, __pyx_k_symbol, sizeof(__pyx_k_symbol), 0, 0, 1, 1}, + {&__pyx_n_s_syms, __pyx_k_syms, sizeof(__pyx_k_syms), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_test_2, __pyx_k_test_2, sizeof(__pyx_k_test_2), 0, 0, 1, 1}, + {&__pyx_n_s_text, __pyx_k_text, sizeof(__pyx_k_text), 0, 0, 1, 1}, + {&__pyx_n_s_times, __pyx_k_times, sizeof(__pyx_k_times), 0, 0, 1, 1}, + {&__pyx_n_s_title, __pyx_k_title, sizeof(__pyx_k_title), 0, 0, 1, 1}, + {&__pyx_n_s_to_final, __pyx_k_to_final, sizeof(__pyx_k_to_final), 0, 0, 1, 1}, + {&__pyx_n_s_to_string, __pyx_k_to_string, sizeof(__pyx_k_to_string), 0, 0, 1, 1}, + {&__pyx_n_b_tropical, __pyx_k_tropical, sizeof(__pyx_k_tropical), 0, 0, 0, 1}, + {&__pyx_n_s_type, __pyx_k_type, sizeof(__pyx_k_type), 0, 0, 1, 1}, + {&__pyx_n_b_uniform, __pyx_k_uniform, sizeof(__pyx_k_uniform), 0, 0, 0, 1}, + {&__pyx_n_s_unique, __pyx_k_unique, sizeof(__pyx_k_unique), 0, 0, 1, 1}, + {&__pyx_n_s_unknown_isymbol, __pyx_k_unknown_isymbol, sizeof(__pyx_k_unknown_isymbol), 0, 0, 1, 1}, + {&__pyx_n_s_unknown_osymbol, __pyx_k_unknown_osymbol, sizeof(__pyx_k_unknown_osymbol), 0, 0, 1, 1}, + {&__pyx_kp_b_unspecified, __pyx_k_unspecified, sizeof(__pyx_k_unspecified), 0, 0, 0, 0}, + {&__pyx_n_s_utf8, __pyx_k_utf8, sizeof(__pyx_k_utf8), 0, 0, 1, 1}, + {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1}, + {&__pyx_n_b_vector, __pyx_k_vector, sizeof(__pyx_k_vector), 0, 0, 0, 1}, + {&__pyx_n_s_verify, __pyx_k_verify, sizeof(__pyx_k_verify), 0, 0, 1, 1}, + {&__pyx_n_s_vertical, __pyx_k_vertical, sizeof(__pyx_k_vertical), 0, 0, 1, 1}, + {&__pyx_n_s_w, __pyx_k_w, sizeof(__pyx_k_w), 0, 0, 1, 1}, + {&__pyx_n_s_warning, __pyx_k_warning, sizeof(__pyx_k_warning), 0, 0, 1, 1}, + {&__pyx_n_s_weight, __pyx_k_weight, sizeof(__pyx_k_weight), 0, 0, 1, 1}, + {&__pyx_n_s_weight_type, __pyx_k_weight_type, sizeof(__pyx_k_weight_type), 0, 0, 1, 1}, + {&__pyx_n_s_weighted, __pyx_k_weighted, sizeof(__pyx_k_weighted), 0, 0, 1, 1}, + {&__pyx_n_s_width, __pyx_k_width, sizeof(__pyx_k_width), 0, 0, 1, 1}, + {&__pyx_n_s_write, __pyx_k_write, sizeof(__pyx_k_write), 0, 0, 1, 1}, + {&__pyx_n_s_write_text, __pyx_k_write_text, sizeof(__pyx_k_write_text), 0, 0, 1, 1}, + {&__pyx_n_b_write_to_string, __pyx_k_write_to_string, sizeof(__pyx_k_write_to_string), 0, 0, 0, 1}, + {&__pyx_n_s_write_to_string, __pyx_k_write_to_string, sizeof(__pyx_k_write_to_string), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 126, __pyx_L1_error) + __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(0, 136, __pyx_L1_error) + __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(0, 141, __pyx_L1_error) + __pyx_builtin_IOError = __Pyx_GetBuiltinName(__pyx_n_s_IOError); if (!__pyx_builtin_IOError) __PYX_ERR(0, 146, __pyx_L1_error) + __pyx_builtin_object = __Pyx_GetBuiltinName(__pyx_n_s_object); if (!__pyx_builtin_object) __PYX_ERR(0, 2742, __pyx_L1_error) + __pyx_builtin_staticmethod = __Pyx_GetBuiltinName(__pyx_n_s_staticmethod); if (!__pyx_builtin_staticmethod) __PYX_ERR(0, 2762, __pyx_L1_error) + __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(0, 370, __pyx_L1_error) + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error) + __pyx_builtin_StopIteration = __Pyx_GetBuiltinName(__pyx_n_s_StopIteration); if (!__pyx_builtin_StopIteration) __PYX_ERR(0, 1145, __pyx_L1_error) + __pyx_builtin_KeyError = __Pyx_GetBuiltinName(__pyx_n_s_KeyError); if (!__pyx_builtin_KeyError) __PYX_ERR(0, 4357, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "pywrapfst.pyx":388 + * cdef void _check_weight(self) except *: + * if self.type() == b"none": + * raise FstArgError("Weight type not found") # <<<<<<<<<<<<<< + * if self.to_string() == b"BadNumber": + * raise FstBadWeightError("Invalid weight") + */ + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_Weight_type_not_found); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + + /* "pywrapfst.pyx":390 + * raise FstArgError("Weight type not found") + * if self.to_string() == b"BadNumber": + * raise FstBadWeightError("Invalid weight") # <<<<<<<<<<<<<< + * + * cpdef Weight copy(self): + */ + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_Invalid_weight); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 390, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._weight cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._weight cannot be converted to a Python object for pickling") + */ + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s_self__weight_cannot_be_converted); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "(tree fragment)":4 + * raise TypeError("self._weight cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._weight cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_self__weight_cannot_be_converted); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "pywrapfst.pyx":638 + * tostring(weight_type)))) + * if result._weight.get().Type() == b"none": + * raise FstArgError("Weight type not found") # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_Weight_type_not_found); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 638, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "pywrapfst.pyx":647 + * fst.WeightClass.One(tostring(weight_type)))) + * if result._weight.get().Type() == b"none": + * raise FstArgError("Weight type not found") # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_Weight_type_not_found); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 647, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._table cannot be converted to a Python object for pickling") + */ + __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_self__table_cannot_be_converted); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + + /* "(tree fragment)":4 + * raise TypeError("self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_self__table_cannot_be_converted); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._encoder,self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._encoder,self._table cannot be converted to a Python object for pickling") + */ + __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_self__encoder_self__table_cannot); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); + + /* "(tree fragment)":4 + * raise TypeError("self._encoder,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._encoder,self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_self__encoder_self__table_cannot); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._fst,self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._fst,self._table cannot be converted to a Python object for pickling") + */ + __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_self__fst_self__table_cannot_be); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + + /* "(tree fragment)":4 + * raise TypeError("self._fst,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._fst,self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_s_self__fst_self__table_cannot_be); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._table cannot be converted to a Python object for pickling") + */ + __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_self__table_cannot_be_converted); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__14); + __Pyx_GIVEREF(__pyx_tuple__14); + + /* "(tree fragment)":4 + * raise TypeError("self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_self__table_cannot_be_converted); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__15); + __Pyx_GIVEREF(__pyx_tuple__15); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._mfst,self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._mfst,self._table cannot be converted to a Python object for pickling") + */ + __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_s_self__mfst_self__table_cannot_be); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__16); + __Pyx_GIVEREF(__pyx_tuple__16); + + /* "(tree fragment)":4 + * raise TypeError("self._mfst,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._mfst,self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_tuple__17 = PyTuple_Pack(1, __pyx_kp_s_self__mfst_self__table_cannot_be); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__17); + __Pyx_GIVEREF(__pyx_tuple__17); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._smart_table,self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._smart_table,self._table cannot be converted to a Python object for pickling") + */ + __pyx_tuple__18 = PyTuple_Pack(1, __pyx_kp_s_self__smart_table_self__table_ca); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__18); + __Pyx_GIVEREF(__pyx_tuple__18); + + /* "(tree fragment)":4 + * raise TypeError("self._smart_table,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._smart_table,self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_tuple__19 = PyTuple_Pack(1, __pyx_kp_s_self__smart_table_self__table_ca); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__19); + __Pyx_GIVEREF(__pyx_tuple__19); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._siter,self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._siter,self._table cannot be converted to a Python object for pickling") + */ + __pyx_tuple__20 = PyTuple_Pack(1, __pyx_kp_s_self__siter_self__table_cannot_b); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__20); + __Pyx_GIVEREF(__pyx_tuple__20); + + /* "(tree fragment)":4 + * raise TypeError("self._siter,self._table cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._siter,self._table cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_s_self__siter_self__table_cannot_b); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__21); + __Pyx_GIVEREF(__pyx_tuple__21); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._encoder cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._encoder cannot be converted to a Python object for pickling") + */ + __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_s_self__encoder_cannot_be_converte); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__22); + __Pyx_GIVEREF(__pyx_tuple__22); + + /* "(tree fragment)":4 + * raise TypeError("self._encoder cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._encoder cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_s_self__encoder_cannot_be_converte); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__23); + __Pyx_GIVEREF(__pyx_tuple__23); + + /* "pywrapfst.pyx":1400 + * if proc.returncode != 0: # Just to be explicit. + * raise subprocess.CalledProcessError(proc.returncode, self._DOT_TSVG) + * return sout.decode("utf8") # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __pyx_tuple__25 = PyTuple_Pack(1, __pyx_n_s_utf8); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(0, 1400, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__25); + __Pyx_GIVEREF(__pyx_tuple__25); + + /* "pywrapfst.pyx":1576 + * cdef size_t result = self._fst.get().NumArcs(state) + * if result == SIZE_MAX: + * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_tuple__26 = PyTuple_Pack(1, __pyx_kp_s_State_index_out_of_range); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 1576, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__26); + __Pyx_GIVEREF(__pyx_tuple__26); + + /* "pywrapfst.pyx":1598 + * cdef size_t result = self._fst.get().NumInputEpsilons(state) + * if result == SIZE_MAX: + * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_tuple__27 = PyTuple_Pack(1, __pyx_kp_s_State_index_out_of_range); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(0, 1598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__27); + __Pyx_GIVEREF(__pyx_tuple__27); + + /* "pywrapfst.pyx":1620 + * cdef size_t result = self._fst.get().NumOutputEpsilons(state) + * if result == SIZE_MAX: + * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_tuple__28 = PyTuple_Pack(1, __pyx_kp_s_State_index_out_of_range); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 1620, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__28); + __Pyx_GIVEREF(__pyx_tuple__28); + + /* "pywrapfst.pyx":1770 + * cdef stringstream sstrm + * if not self._fst.get().Write(sstrm, "write_to_string"): + * raise FstIOError("Write to string failed") # <<<<<<<<<<<<<< + * return sstrm.str() + * + */ + __pyx_tuple__29 = PyTuple_Pack(1, __pyx_kp_s_Write_to_string_failed); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(0, 1770, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__29); + __Pyx_GIVEREF(__pyx_tuple__29); + + /* "pywrapfst.pyx":1790 + * """ + * if self._fst.get().Properties(fst.kError, True) == fst.kError: + * raise FstOpError("Operation failed") # <<<<<<<<<<<<<< + * + * cdef void _add_arc(self, int64 state, Arc arc) except *: + */ + __pyx_tuple__30 = PyTuple_Pack(1, __pyx_kp_s_Operation_failed); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 1790, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__30); + __Pyx_GIVEREF(__pyx_tuple__30); + + /* "pywrapfst.pyx":1794 + * cdef void _add_arc(self, int64 state, Arc arc) except *: + * if not self._fst.get().ValidStateId(state): + * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< + * if not self._mfst.get().AddArc(state, deref(arc._arc)): + * raise FstOpError("Incompatible or invalid weight type") + */ + __pyx_tuple__31 = PyTuple_Pack(1, __pyx_kp_s_State_index_out_of_range); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(0, 1794, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__31); + __Pyx_GIVEREF(__pyx_tuple__31); + + /* "pywrapfst.pyx":1796 + * raise FstIndexError("State index out of range") + * if not self._mfst.get().AddArc(state, deref(arc._arc)): + * raise FstOpError("Incompatible or invalid weight type") # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + __pyx_tuple__32 = PyTuple_Pack(1, __pyx_kp_s_Incompatible_or_invalid_weight_t); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 1796, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__32); + __Pyx_GIVEREF(__pyx_tuple__32); + + /* "pywrapfst.pyx":1961 + * if not (self._mfst.get().DeleteArcs(state, n) if n else + * self._mfst.get().DeleteArcs(state)): + * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + __pyx_tuple__33 = PyTuple_Pack(1, __pyx_kp_s_State_index_out_of_range); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(0, 1961, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__33); + __Pyx_GIVEREF(__pyx_tuple__33); + + /* "pywrapfst.pyx":1991 + * if states: + * if not self._mfst.get().DeleteStates( states): + * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< + * else: + * self._mfst.get().DeleteStates() + */ + __pyx_tuple__34 = PyTuple_Pack(1, __pyx_kp_s_State_index_out_of_range); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 1991, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__34); + __Pyx_GIVEREF(__pyx_tuple__34); + + /* "pywrapfst.pyx":2260 + * _opairs.get().push_back(fst.LabelPair(before, after)) + * if _ipairs.get().empty() and _opairs.get().empty(): + * raise FstArgError("No relabeling pairs specified.") # <<<<<<<<<<<<<< + * fst.Relabel(self._mfst.get(), deref(_ipairs), deref(_opairs)) + * self._check_mutating_imethod() + */ + __pyx_tuple__43 = PyTuple_Pack(1, __pyx_kp_s_No_relabeling_pairs_specified); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(0, 2260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__43); + __Pyx_GIVEREF(__pyx_tuple__43); + + /* "pywrapfst.pyx":2299 + * bool attach_new_osymbols=True) except *: + * if new_isymbols is None and new_osymbols is None: + * raise FstArgError("No new SymbolTables specified") # <<<<<<<<<<<<<< + * cdef fst.SymbolTable *new_isymbols_ptr = NULL + * if new_isymbols is not None: + */ + __pyx_tuple__44 = PyTuple_Pack(1, __pyx_kp_s_No_new_SymbolTables_specified); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(0, 2299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__44); + __Pyx_GIVEREF(__pyx_tuple__44); + + /* "pywrapfst.pyx":2367 + * cdef void _reserve_arcs(self, int64 state, size_t n) except *: + * if not self._mfst.get().ReserveArcs(state, n): + * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + __pyx_tuple__45 = PyTuple_Pack(1, __pyx_kp_s_State_index_out_of_range); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(0, 2367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__45); + __Pyx_GIVEREF(__pyx_tuple__45); + + /* "pywrapfst.pyx":2494 + * cdef void _set_final(self, int64 state, weight=None) except *: + * if not self._mfst.get().ValidStateId(state): + * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< + * cdef fst.WeightClass wc = _get_WeightClass_or_One(self.weight_type(), + * weight) + */ + __pyx_tuple__50 = PyTuple_Pack(1, __pyx_kp_s_State_index_out_of_range); if (unlikely(!__pyx_tuple__50)) __PYX_ERR(0, 2494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__50); + __Pyx_GIVEREF(__pyx_tuple__50); + + /* "pywrapfst.pyx":2498 + * weight) + * if not self._mfst.get().SetFinal(state, wc): + * raise FstOpError("Incompatible or invalid weight") # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + __pyx_tuple__51 = PyTuple_Pack(1, __pyx_kp_s_Incompatible_or_invalid_weight); if (unlikely(!__pyx_tuple__51)) __PYX_ERR(0, 2498, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__51); + __Pyx_GIVEREF(__pyx_tuple__51); + + /* "pywrapfst.pyx":2598 + * cdef void _set_start(self, int64 state) except *: + * if not self._mfst.get().SetStart(state): + * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + __pyx_tuple__52 = PyTuple_Pack(1, __pyx_kp_s_State_index_out_of_range); if (unlikely(!__pyx_tuple__52)) __PYX_ERR(0, 2598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__52); + __Pyx_GIVEREF(__pyx_tuple__52); + + /* "pywrapfst.pyx":2624 + * # TopSort returns False if the FST is cyclic, and thus can't be TopSorted. + * if not fst.TopSort(self._mfst.get()): + * logging.warning("Cannot topsort cyclic FST.") # <<<<<<<<<<<<<< + * self._check_mutating_imethod() + * + */ + __pyx_tuple__53 = PyTuple_Pack(1, __pyx_kp_s_Cannot_topsort_cyclic_FST); if (unlikely(!__pyx_tuple__53)) __PYX_ERR(0, 2624, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__53); + __Pyx_GIVEREF(__pyx_tuple__53); + + /* "pywrapfst.pyx":2693 + * cdef _Fst _init_Fst(FstClass_ptr tfst): + * if tfst.Properties(fst.kError, True): + * raise FstOpError("Operation failed") # <<<<<<<<<<<<<< + * cdef _Fst ofst = _Fst.__new__(_Fst) + * ofst._fst.reset(tfst) + */ + __pyx_tuple__54 = PyTuple_Pack(1, __pyx_kp_s_Operation_failed); if (unlikely(!__pyx_tuple__54)) __PYX_ERR(0, 2693, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__54); + __Pyx_GIVEREF(__pyx_tuple__54); + + /* "pywrapfst.pyx":2701 + * cdef _MutableFst _init_MutableFst(MutableFstClass_ptr tfst): + * if tfst.Properties(fst.kError, True): + * raise FstOpError("Operation failed") # <<<<<<<<<<<<<< + * cdef _MutableFst ofst = _MutableFst.__new__(_MutableFst) + * ofst._fst.reset(tfst) + */ + __pyx_tuple__55 = PyTuple_Pack(1, __pyx_kp_s_Operation_failed); if (unlikely(!__pyx_tuple__55)) __PYX_ERR(0, 2701, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__55); + __Pyx_GIVEREF(__pyx_tuple__55); + + /* "pywrapfst.pyx":2738 + * tfst.reset(fst.FstClass.ReadFromStream(sstrm, b"")) + * if tfst.get() == NULL: + * raise FstIOError("Read failed: ") # <<<<<<<<<<<<<< + * return _init_XFst(tfst.release()) + * + */ + __pyx_tuple__56 = PyTuple_Pack(1, __pyx_kp_s_Read_failed_string); if (unlikely(!__pyx_tuple__56)) __PYX_ERR(0, 2738, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__56); + __Pyx_GIVEREF(__pyx_tuple__56); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._arc cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._arc cannot be converted to a Python object for pickling") + */ + __pyx_tuple__57 = PyTuple_Pack(1, __pyx_kp_s_self__arc_cannot_be_converted_to); if (unlikely(!__pyx_tuple__57)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__57); + __Pyx_GIVEREF(__pyx_tuple__57); + + /* "(tree fragment)":4 + * raise TypeError("self._arc cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._arc cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_tuple__58 = PyTuple_Pack(1, __pyx_kp_s_self__arc_cannot_be_converted_to); if (unlikely(!__pyx_tuple__58)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__58); + __Pyx_GIVEREF(__pyx_tuple__58); + + /* "pywrapfst.pyx":2978 + * def __init__(self, _Fst ifst, int64 state): + * if not ifst._fst.get().ValidStateId(state): + * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< + * # Makes copy of the shared_ptr, potentially extending the FST's lifetime. + * self._fst = ifst._fst + */ + __pyx_tuple__59 = PyTuple_Pack(1, __pyx_kp_s_State_index_out_of_range); if (unlikely(!__pyx_tuple__59)) __PYX_ERR(0, 2978, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__59); + __Pyx_GIVEREF(__pyx_tuple__59); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._aiter,self._fst cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._aiter,self._fst cannot be converted to a Python object for pickling") + */ + __pyx_tuple__60 = PyTuple_Pack(1, __pyx_kp_s_self__aiter_self__fst_cannot_be); if (unlikely(!__pyx_tuple__60)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__60); + __Pyx_GIVEREF(__pyx_tuple__60); + + /* "(tree fragment)":4 + * raise TypeError("self._aiter,self._fst cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._aiter,self._fst cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_tuple__61 = PyTuple_Pack(1, __pyx_kp_s_self__aiter_self__fst_cannot_be); if (unlikely(!__pyx_tuple__61)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__61); + __Pyx_GIVEREF(__pyx_tuple__61); + + /* "pywrapfst.pyx":3090 + * def __init__(self, _MutableFst ifst, int64 state): + * if not ifst._fst.get().ValidStateId(state): + * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< + * # Makes copy of the shared_ptr, potentially extending the FST's lifetime. + * self._mfst = ifst._mfst + */ + __pyx_tuple__62 = PyTuple_Pack(1, __pyx_kp_s_State_index_out_of_range); if (unlikely(!__pyx_tuple__62)) __PYX_ERR(0, 3090, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__62); + __Pyx_GIVEREF(__pyx_tuple__62); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._aiter,self._mfst cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._aiter,self._mfst cannot be converted to a Python object for pickling") + */ + __pyx_tuple__63 = PyTuple_Pack(1, __pyx_kp_s_self__aiter_self__mfst_cannot_be); if (unlikely(!__pyx_tuple__63)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__63); + __Pyx_GIVEREF(__pyx_tuple__63); + + /* "(tree fragment)":4 + * raise TypeError("self._aiter,self._mfst cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._aiter,self._mfst cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_tuple__64 = PyTuple_Pack(1, __pyx_kp_s_self__aiter_self__mfst_cannot_be); if (unlikely(!__pyx_tuple__64)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__64); + __Pyx_GIVEREF(__pyx_tuple__64); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._fst,self._siter cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._fst,self._siter cannot be converted to a Python object for pickling") + */ + __pyx_tuple__65 = PyTuple_Pack(1, __pyx_kp_s_self__fst_self__siter_cannot_be); if (unlikely(!__pyx_tuple__65)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__65); + __Pyx_GIVEREF(__pyx_tuple__65); + + /* "(tree fragment)":4 + * raise TypeError("self._fst,self._siter cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._fst,self._siter cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_tuple__66 = PyTuple_Pack(1, __pyx_kp_s_self__fst_self__siter_cannot_be); if (unlikely(!__pyx_tuple__66)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__66); + __Pyx_GIVEREF(__pyx_tuple__66); + + /* "pywrapfst.pyx":4190 + * self._sstrm.reset(new stringstream()) + * if tfst.get() == NULL: + * raise FstOpError("Compilation failed") # <<<<<<<<<<<<<< + * return _init_XFst(tfst.release()) + * + */ + __pyx_tuple__90 = PyTuple_Pack(1, __pyx_kp_s_Compilation_failed); if (unlikely(!__pyx_tuple__90)) __PYX_ERR(0, 4190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__90); + __Pyx_GIVEREF(__pyx_tuple__90); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + __pyx_tuple__91 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__91)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__91); + __Pyx_GIVEREF(__pyx_tuple__91); + + /* "(tree fragment)":4 + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + */ + __pyx_tuple__92 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__92)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__92); + __Pyx_GIVEREF(__pyx_tuple__92); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._reader cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._reader cannot be converted to a Python object for pickling") + */ + __pyx_tuple__93 = PyTuple_Pack(1, __pyx_kp_s_self__reader_cannot_be_converted); if (unlikely(!__pyx_tuple__93)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__93); + __Pyx_GIVEREF(__pyx_tuple__93); + + /* "(tree fragment)":4 + * raise TypeError("self._reader cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._reader cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_tuple__94 = PyTuple_Pack(1, __pyx_kp_s_self__reader_cannot_be_converted); if (unlikely(!__pyx_tuple__94)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__94); + __Pyx_GIVEREF(__pyx_tuple__94); + + /* "pywrapfst.pyx":4443 + * # used by the FAR was initialized to use. + * if not self._writer.get().Add(tostring(key), deref(ifst._fst)): + * raise FstOpError("Incompatible or invalid arc type") # <<<<<<<<<<<<<< + * # An error here usually indicates a key out of order. + * if self._writer.get().Error(): + */ + __pyx_tuple__95 = PyTuple_Pack(1, __pyx_kp_s_Incompatible_or_invalid_arc_type); if (unlikely(!__pyx_tuple__95)) __PYX_ERR(0, 4443, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__95); + __Pyx_GIVEREF(__pyx_tuple__95); + + /* "pywrapfst.pyx":4446 + * # An error here usually indicates a key out of order. + * if self._writer.get().Error(): + * raise FstArgError("Key out of order") # <<<<<<<<<<<<<< + * + * cpdef string arc_type(self): + */ + __pyx_tuple__96 = PyTuple_Pack(1, __pyx_kp_s_Key_out_of_order); if (unlikely(!__pyx_tuple__96)) __PYX_ERR(0, 4446, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__96); + __Pyx_GIVEREF(__pyx_tuple__96); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("self._writer cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._writer cannot be converted to a Python object for pickling") + */ + __pyx_tuple__97 = PyTuple_Pack(1, __pyx_kp_s_self__writer_cannot_be_converted); if (unlikely(!__pyx_tuple__97)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__97); + __Pyx_GIVEREF(__pyx_tuple__97); + + /* "(tree fragment)":4 + * raise TypeError("self._writer cannot be converted to a Python object for pickling") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("self._writer cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + */ + __pyx_tuple__98 = PyTuple_Pack(1, __pyx_kp_s_self__writer_cannot_be_converted); if (unlikely(!__pyx_tuple__98)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__98); + __Pyx_GIVEREF(__pyx_tuple__98); + + /* "pywrapfst.pyx":456 + * + * + * def plus(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< + * """ + * plus(lhs, rhs) + */ + __pyx_tuple__99 = PyTuple_Pack(3, __pyx_n_s_lhs, __pyx_n_s_rhs, __pyx_n_s_result); if (unlikely(!__pyx_tuple__99)) __PYX_ERR(0, 456, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__99); + __Pyx_GIVEREF(__pyx_tuple__99); + __pyx_codeobj__100 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__99, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pywrapfst_pyx, __pyx_n_s_plus, 456, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__100)) __PYX_ERR(0, 456, __pyx_L1_error) + + /* "pywrapfst.pyx":488 + * + * + * def times(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< + * """ + * times(lhs, rhs) + */ + __pyx_tuple__101 = PyTuple_Pack(3, __pyx_n_s_lhs, __pyx_n_s_rhs, __pyx_n_s_result); if (unlikely(!__pyx_tuple__101)) __PYX_ERR(0, 488, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__101); + __Pyx_GIVEREF(__pyx_tuple__101); + __pyx_codeobj__102 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__101, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pywrapfst_pyx, __pyx_n_s_times, 488, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__102)) __PYX_ERR(0, 488, __pyx_L1_error) + + /* "pywrapfst.pyx":520 + * + * + * def divide(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< + * """ + * divide(lhs, rhs) + */ + __pyx_tuple__103 = PyTuple_Pack(3, __pyx_n_s_lhs, __pyx_n_s_rhs, __pyx_n_s_result); if (unlikely(!__pyx_tuple__103)) __PYX_ERR(0, 520, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__103); + __Pyx_GIVEREF(__pyx_tuple__103); + __pyx_codeobj__104 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__103, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pywrapfst_pyx, __pyx_n_s_divide, 520, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__104)) __PYX_ERR(0, 520, __pyx_L1_error) + + /* "pywrapfst.pyx":553 + * + * + * def power(Weight w, size_t n): # <<<<<<<<<<<<<< + * """ + * power(lhs, rhs) + */ + __pyx_tuple__105 = PyTuple_Pack(3, __pyx_n_s_w, __pyx_n_s_n, __pyx_n_s_result); if (unlikely(!__pyx_tuple__105)) __PYX_ERR(0, 553, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__105); + __Pyx_GIVEREF(__pyx_tuple__105); + __pyx_codeobj__106 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__105, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pywrapfst_pyx, __pyx_n_s_power, 553, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__106)) __PYX_ERR(0, 553, __pyx_L1_error) + + /* "pywrapfst.pyx":2742 + * + * + * class Fst(object): # <<<<<<<<<<<<<< + * + * """ + */ + __pyx_tuple__107 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__107)) __PYX_ERR(0, 2742, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__107); + __Pyx_GIVEREF(__pyx_tuple__107); + + /* "pywrapfst.pyx":2759 + * """ + * + * def __new__(cls, arc_type=b"standard"): # <<<<<<<<<<<<<< + * return _create_Fst(arc_type) + * + */ + __pyx_tuple__108 = PyTuple_Pack(2, __pyx_n_s_cls, __pyx_n_s_arc_type); if (unlikely(!__pyx_tuple__108)) __PYX_ERR(0, 2759, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__108); + __Pyx_GIVEREF(__pyx_tuple__108); + __pyx_codeobj__109 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__108, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pywrapfst_pyx, __pyx_n_s_new, 2759, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__109)) __PYX_ERR(0, 2759, __pyx_L1_error) + __pyx_tuple__110 = PyTuple_Pack(1, ((PyObject*)__pyx_n_b_standard)); if (unlikely(!__pyx_tuple__110)) __PYX_ERR(0, 2759, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__110); + __Pyx_GIVEREF(__pyx_tuple__110); + + /* "pywrapfst.pyx":2763 + * + * @staticmethod + * def read(filename): # <<<<<<<<<<<<<< + * """ + * read(filename): + */ + __pyx_tuple__111 = PyTuple_Pack(1, __pyx_n_s_filename); if (unlikely(!__pyx_tuple__111)) __PYX_ERR(0, 2763, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__111); + __Pyx_GIVEREF(__pyx_tuple__111); + __pyx_codeobj__112 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__111, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pywrapfst_pyx, __pyx_n_s_read, 2763, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__112)) __PYX_ERR(0, 2763, __pyx_L1_error) + + /* "pywrapfst.pyx":2781 + * + * @staticmethod + * def read_from_string(state): # <<<<<<<<<<<<<< + * """ + * read_from_string(string, fst_type=None) + */ + __pyx_tuple__113 = PyTuple_Pack(1, __pyx_n_s_state); if (unlikely(!__pyx_tuple__113)) __PYX_ERR(0, 2781, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__113); + __Pyx_GIVEREF(__pyx_tuple__113); + __pyx_codeobj__114 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__113, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pywrapfst_pyx, __pyx_n_s_read_from_string_2, 2781, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__114)) __PYX_ERR(0, 2781, __pyx_L1_error) + + /* "pywrapfst.pyx":3949 + * + * + * def shortestdistance(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kShortestDelta, + * int64 nstate=fst.kNoStateId, + */ + __pyx_tuple__115 = PyTuple_Pack(8, __pyx_n_s_ifst, __pyx_n_s_delta, __pyx_n_s_nstate, __pyx_n_s_queue_type, __pyx_n_s_reverse, __pyx_n_s_distance, __pyx_n_s_weight_type, __pyx_n_s_weight); if (unlikely(!__pyx_tuple__115)) __PYX_ERR(0, 3949, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__115); + __Pyx_GIVEREF(__pyx_tuple__115); + __pyx_codeobj__116 = (PyObject*)__Pyx_PyCode_New(5, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__115, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pywrapfst_pyx, __pyx_n_s_shortestdistance, 3949, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__116)) __PYX_ERR(0, 3949, __pyx_L1_error) + + /* "pywrapfst.pyx":4492 + * + * @atexit.register + * def _reset_fst_error_fatal(): # <<<<<<<<<<<<<< + * fst.FLAGS_fst_error_fatal = _fst_error_fatal_old + * + */ + __pyx_codeobj__117 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pywrapfst_pyx, __pyx_n_s_reset_fst_error_fatal, 4492, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__117)) __PYX_ERR(0, 4492, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +#if PY_MAJOR_VERSION < 3 +PyMODINIT_FUNC initpywrapfst(void); /*proto*/ +PyMODINIT_FUNC initpywrapfst(void) +#else +PyMODINIT_FUNC PyInit_pywrapfst(void); /*proto*/ +PyMODINIT_FUNC PyInit_pywrapfst(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +static int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name) { + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + result = PyDict_SetItemString(moddict, to_name, value); + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + if (__pyx_m) + return __Pyx_NewRef(__pyx_m); + modname = PyObject_GetAttrString(spec, "name"); + if (unlikely(!modname)) goto bad; + module = PyModule_NewObject(modname); + Py_DECREF(modname); + if (unlikely(!module)) goto bad; + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__") < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__") < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__") < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__") < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; +} + + +static int __pyx_pymod_exec_pywrapfst(PyObject *__pyx_pyinit_module) +#endif +#endif +{ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __pyx_t_10basictypes_int64 __pyx_t_5; + std::string __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m && __pyx_m == __pyx_pyinit_module) return 0; + #endif + #if CYTHON_REFNANNY + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); + if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); + } + #endif + __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_pywrapfst(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("pywrapfst", __pyx_methods, __pyx_k_Python_interface_to_the_FST_scri, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + #if CYTHON_COMPILING_IN_PYPY + Py_INCREF(__pyx_b); + #endif + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_pywrapfst) { + if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "pywrapfst")) { + if (unlikely(PyDict_SetItemString(modules, "pywrapfst", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global init code ---*/ + /*--- Variable export code ---*/ + /*--- Function export code ---*/ + if (__Pyx_ExportFunction("tostring", (void (*)(void))__pyx_f_9pywrapfst_tostring, "std::string (PyObject *, struct __pyx_opt_args_9pywrapfst_tostring *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("weight_tostring", (void (*)(void))__pyx_f_9pywrapfst_weight_tostring, "std::string (PyObject *, struct __pyx_opt_args_9pywrapfst_weight_tostring *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_get_compose_filter", (void (*)(void))__pyx_f_9pywrapfst__get_compose_filter, "enum fst::ComposeFilter (std::string const &)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_get_determinize_type", (void (*)(void))__pyx_f_9pywrapfst__get_determinize_type, "enum fst::DeterminizeType (std::string const &)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_get_queue_type", (void (*)(void))__pyx_f_9pywrapfst__get_queue_type, "enum fst::QueueType (std::string const &)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_get_rand_arc_selection", (void (*)(void))__pyx_f_9pywrapfst__get_rand_arc_selection, "enum fst::script::RandArcSelection (std::string const &)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_get_replace_label_type", (void (*)(void))__pyx_f_9pywrapfst__get_replace_label_type, "enum fst::ReplaceLabelType (std::string const &, bool)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_get_WeightClass_or_One", (void (*)(void))__pyx_f_9pywrapfst__get_WeightClass_or_One, "fst::script::WeightClass (std::string const &, PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_get_WeightClass_or_Zero", (void (*)(void))__pyx_f_9pywrapfst__get_WeightClass_or_Zero, "fst::script::WeightClass (std::string const &, PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_Zero", (void (*)(void))__pyx_f_9pywrapfst__Zero, "struct __pyx_obj_9pywrapfst_Weight *(PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_One", (void (*)(void))__pyx_f_9pywrapfst__One, "struct __pyx_obj_9pywrapfst_Weight *(PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_NoWeight", (void (*)(void))__pyx_f_9pywrapfst__NoWeight, "struct __pyx_obj_9pywrapfst_Weight *(PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_plus", (void (*)(void))__pyx_f_9pywrapfst__plus, "struct __pyx_obj_9pywrapfst_Weight *(struct __pyx_obj_9pywrapfst_Weight *, struct __pyx_obj_9pywrapfst_Weight *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_times", (void (*)(void))__pyx_f_9pywrapfst__times, "struct __pyx_obj_9pywrapfst_Weight *(struct __pyx_obj_9pywrapfst_Weight *, struct __pyx_obj_9pywrapfst_Weight *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_divide", (void (*)(void))__pyx_f_9pywrapfst__divide, "struct __pyx_obj_9pywrapfst_Weight *(struct __pyx_obj_9pywrapfst_Weight *, struct __pyx_obj_9pywrapfst_Weight *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_power", (void (*)(void))__pyx_f_9pywrapfst__power, "struct __pyx_obj_9pywrapfst_Weight *(struct __pyx_obj_9pywrapfst_Weight *, size_t)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_init_EncodeMapperSymbolTable", (void (*)(void))__pyx_f_9pywrapfst__init_EncodeMapperSymbolTable, "struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *(fst::SymbolTable *, std::shared_ptr )") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_init_FstSymbolTable", (void (*)(void))__pyx_f_9pywrapfst__init_FstSymbolTable, "struct __pyx_obj_9pywrapfst__FstSymbolTable *(fst::SymbolTable *, std::shared_ptr )") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_init_MutableFstSymbolTable", (void (*)(void))__pyx_f_9pywrapfst__init_MutableFstSymbolTable, "struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *(fst::SymbolTable *, std::shared_ptr )") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_init_SymbolTable", (void (*)(void))__pyx_f_9pywrapfst__init_SymbolTable, "struct __pyx_obj_9pywrapfst_SymbolTable *(fst::SymbolTable *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_init_Fst", (void (*)(void))__pyx_f_9pywrapfst__init_Fst, "struct __pyx_obj_9pywrapfst__Fst *(__pyx_t_9pywrapfst_FstClass_ptr)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_init_MutableFst", (void (*)(void))__pyx_f_9pywrapfst__init_MutableFst, "struct __pyx_obj_9pywrapfst__MutableFst *(__pyx_t_9pywrapfst_MutableFstClass_ptr)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_init_XFst", (void (*)(void))__pyx_f_9pywrapfst__init_XFst, "struct __pyx_obj_9pywrapfst__Fst *(__pyx_t_9pywrapfst_FstClass_ptr)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_create_Fst", (void (*)(void))__pyx_f_9pywrapfst__create_Fst, "struct __pyx_obj_9pywrapfst__MutableFst *(struct __pyx_opt_args_9pywrapfst__create_Fst *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_read", (void (*)(void))__pyx_f_9pywrapfst__read, "struct __pyx_obj_9pywrapfst__Fst *(PyObject *, int __pyx_skip_dispatch)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_read_from_string", (void (*)(void))__pyx_f_9pywrapfst__read_from_string, "struct __pyx_obj_9pywrapfst__Fst *(PyObject *, int __pyx_skip_dispatch)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_init_Arc", (void (*)(void))__pyx_f_9pywrapfst__init_Arc, "struct __pyx_obj_9pywrapfst_Arc *(fst::script::ArcClass const &)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_map", (void (*)(void))__pyx_f_9pywrapfst__map, "struct __pyx_obj_9pywrapfst__Fst *(struct __pyx_obj_9pywrapfst__Fst *, struct __pyx_opt_args_9pywrapfst__map *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("arcmap", (void (*)(void))__pyx_f_9pywrapfst_arcmap, "struct __pyx_obj_9pywrapfst__Fst *(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_arcmap *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("compose", (void (*)(void))__pyx_f_9pywrapfst_compose, "struct __pyx_obj_9pywrapfst__MutableFst *(struct __pyx_obj_9pywrapfst__Fst *, struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_compose *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("convert", (void (*)(void))__pyx_f_9pywrapfst_convert, "struct __pyx_obj_9pywrapfst__Fst *(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_convert *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("determinize", (void (*)(void))__pyx_f_9pywrapfst_determinize, "struct __pyx_obj_9pywrapfst__MutableFst *(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_determinize *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("difference", (void (*)(void))__pyx_f_9pywrapfst_difference, "struct __pyx_obj_9pywrapfst__MutableFst *(struct __pyx_obj_9pywrapfst__Fst *, struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_difference *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("disambiguate", (void (*)(void))__pyx_f_9pywrapfst_disambiguate, "struct __pyx_obj_9pywrapfst__MutableFst *(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_disambiguate *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("epsnormalize", (void (*)(void))__pyx_f_9pywrapfst_epsnormalize, "struct __pyx_obj_9pywrapfst__MutableFst *(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_epsnormalize *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("equal", (void (*)(void))__pyx_f_9pywrapfst_equal, "bool (struct __pyx_obj_9pywrapfst__Fst *, struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_equal *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("equivalent", (void (*)(void))__pyx_f_9pywrapfst_equivalent, "bool (struct __pyx_obj_9pywrapfst__Fst *, struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_equivalent *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("intersect", (void (*)(void))__pyx_f_9pywrapfst_intersect, "struct __pyx_obj_9pywrapfst__MutableFst *(struct __pyx_obj_9pywrapfst__Fst *, struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_intersect *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("isomorphic", (void (*)(void))__pyx_f_9pywrapfst_isomorphic, "bool (struct __pyx_obj_9pywrapfst__Fst *, struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_isomorphic *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("prune", (void (*)(void))__pyx_f_9pywrapfst_prune, "struct __pyx_obj_9pywrapfst__MutableFst *(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_prune *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("push", (void (*)(void))__pyx_f_9pywrapfst_push, "struct __pyx_obj_9pywrapfst__MutableFst *(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_push *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("randequivalent", (void (*)(void))__pyx_f_9pywrapfst_randequivalent, "bool (struct __pyx_obj_9pywrapfst__Fst *, struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_randequivalent *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("randgen", (void (*)(void))__pyx_f_9pywrapfst_randgen, "struct __pyx_obj_9pywrapfst__MutableFst *(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_randgen *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("replace", (void (*)(void))__pyx_f_9pywrapfst_replace, "struct __pyx_obj_9pywrapfst__MutableFst *(PyObject *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_replace *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("reverse", (void (*)(void))__pyx_f_9pywrapfst_reverse, "struct __pyx_obj_9pywrapfst__MutableFst *(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_reverse *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_shortestdistance", (void (*)(void))__pyx_f_9pywrapfst__shortestdistance, "std::vector *(struct __pyx_obj_9pywrapfst__Fst *, struct __pyx_opt_args_9pywrapfst__shortestdistance *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("shortestpath", (void (*)(void))__pyx_f_9pywrapfst_shortestpath, "struct __pyx_obj_9pywrapfst__MutableFst *(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_shortestpath *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("statemap", (void (*)(void))__pyx_f_9pywrapfst_statemap, "struct __pyx_obj_9pywrapfst__Fst *(struct __pyx_obj_9pywrapfst__Fst *, PyObject *, int __pyx_skip_dispatch)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("synchronize", (void (*)(void))__pyx_f_9pywrapfst_synchronize, "struct __pyx_obj_9pywrapfst__MutableFst *(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Type init code ---*/ + __pyx_vtabptr_9pywrapfst_Weight = &__pyx_vtable_9pywrapfst_Weight; + __pyx_vtable_9pywrapfst_Weight._check_weight = (void (*)(struct __pyx_obj_9pywrapfst_Weight *))__pyx_f_9pywrapfst_6Weight__check_weight; + __pyx_vtable_9pywrapfst_Weight.copy = (struct __pyx_obj_9pywrapfst_Weight *(*)(struct __pyx_obj_9pywrapfst_Weight *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_6Weight_copy; + __pyx_vtable_9pywrapfst_Weight.to_string = (std::string (*)(struct __pyx_obj_9pywrapfst_Weight *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_6Weight_to_string; + __pyx_vtable_9pywrapfst_Weight.type = (std::string (*)(struct __pyx_obj_9pywrapfst_Weight *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_6Weight_type; + if (PyType_Ready(&__pyx_type_9pywrapfst_Weight) < 0) __PYX_ERR(0, 348, __pyx_L1_error) + __pyx_type_9pywrapfst_Weight.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_9pywrapfst_Weight.tp_dict, __pyx_vtabptr_9pywrapfst_Weight) < 0) __PYX_ERR(0, 348, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "Weight", (PyObject *)&__pyx_type_9pywrapfst_Weight) < 0) __PYX_ERR(0, 348, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst_Weight) < 0) __PYX_ERR(0, 348, __pyx_L1_error) + __pyx_ptype_9pywrapfst_Weight = &__pyx_type_9pywrapfst_Weight; + __pyx_vtabptr_9pywrapfst__SymbolTable = &__pyx_vtable_9pywrapfst__SymbolTable; + __pyx_vtable_9pywrapfst__SymbolTable.available_key = (__pyx_t_10basictypes_int64 (*)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12_SymbolTable_available_key; + __pyx_vtable_9pywrapfst__SymbolTable.checksum = (std::string (*)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12_SymbolTable_checksum; + __pyx_vtable_9pywrapfst__SymbolTable.copy = (struct __pyx_obj_9pywrapfst_SymbolTable *(*)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12_SymbolTable_copy; + __pyx_vtable_9pywrapfst__SymbolTable.get_nth_key = (__pyx_t_10basictypes_int64 (*)(struct __pyx_obj_9pywrapfst__SymbolTable *, Py_ssize_t, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12_SymbolTable_get_nth_key; + __pyx_vtable_9pywrapfst__SymbolTable.labeled_checksum = (std::string (*)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12_SymbolTable_labeled_checksum; + __pyx_vtable_9pywrapfst__SymbolTable.member = (bool (*)(struct __pyx_obj_9pywrapfst__SymbolTable *, PyObject *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12_SymbolTable_member; + __pyx_vtable_9pywrapfst__SymbolTable.name = (std::string (*)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12_SymbolTable_name; + __pyx_vtable_9pywrapfst__SymbolTable.num_symbols = (size_t (*)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12_SymbolTable_num_symbols; + __pyx_vtable_9pywrapfst__SymbolTable.write = (void (*)(struct __pyx_obj_9pywrapfst__SymbolTable *, PyObject *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12_SymbolTable_write; + __pyx_vtable_9pywrapfst__SymbolTable.write_text = (void (*)(struct __pyx_obj_9pywrapfst__SymbolTable *, PyObject *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12_SymbolTable_write_text; + if (PyType_Ready(&__pyx_type_9pywrapfst__SymbolTable) < 0) __PYX_ERR(0, 675, __pyx_L1_error) + __pyx_type_9pywrapfst__SymbolTable.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_9pywrapfst__SymbolTable.tp_dict, __pyx_vtabptr_9pywrapfst__SymbolTable) < 0) __PYX_ERR(0, 675, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "_SymbolTable", (PyObject *)&__pyx_type_9pywrapfst__SymbolTable) < 0) __PYX_ERR(0, 675, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst__SymbolTable) < 0) __PYX_ERR(0, 675, __pyx_L1_error) + __pyx_ptype_9pywrapfst__SymbolTable = &__pyx_type_9pywrapfst__SymbolTable; + __pyx_vtabptr_9pywrapfst__EncodeMapperSymbolTable = &__pyx_vtable_9pywrapfst__EncodeMapperSymbolTable; + __pyx_vtable_9pywrapfst__EncodeMapperSymbolTable.__pyx_base = *__pyx_vtabptr_9pywrapfst__SymbolTable; + __pyx_type_9pywrapfst__EncodeMapperSymbolTable.tp_base = __pyx_ptype_9pywrapfst__SymbolTable; + if (PyType_Ready(&__pyx_type_9pywrapfst__EncodeMapperSymbolTable) < 0) __PYX_ERR(0, 839, __pyx_L1_error) + __pyx_type_9pywrapfst__EncodeMapperSymbolTable.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_9pywrapfst__EncodeMapperSymbolTable.tp_dict, __pyx_vtabptr_9pywrapfst__EncodeMapperSymbolTable) < 0) __PYX_ERR(0, 839, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "_EncodeMapperSymbolTable", (PyObject *)&__pyx_type_9pywrapfst__EncodeMapperSymbolTable) < 0) __PYX_ERR(0, 839, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst__EncodeMapperSymbolTable) < 0) __PYX_ERR(0, 839, __pyx_L1_error) + __pyx_ptype_9pywrapfst__EncodeMapperSymbolTable = &__pyx_type_9pywrapfst__EncodeMapperSymbolTable; + __pyx_vtabptr_9pywrapfst__FstSymbolTable = &__pyx_vtable_9pywrapfst__FstSymbolTable; + __pyx_vtable_9pywrapfst__FstSymbolTable.__pyx_base = *__pyx_vtabptr_9pywrapfst__SymbolTable; + __pyx_type_9pywrapfst__FstSymbolTable.tp_base = __pyx_ptype_9pywrapfst__SymbolTable; + if (PyType_Ready(&__pyx_type_9pywrapfst__FstSymbolTable) < 0) __PYX_ERR(0, 859, __pyx_L1_error) + __pyx_type_9pywrapfst__FstSymbolTable.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_9pywrapfst__FstSymbolTable.tp_dict, __pyx_vtabptr_9pywrapfst__FstSymbolTable) < 0) __PYX_ERR(0, 859, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "_FstSymbolTable", (PyObject *)&__pyx_type_9pywrapfst__FstSymbolTable) < 0) __PYX_ERR(0, 859, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst__FstSymbolTable) < 0) __PYX_ERR(0, 859, __pyx_L1_error) + __pyx_ptype_9pywrapfst__FstSymbolTable = &__pyx_type_9pywrapfst__FstSymbolTable; + __pyx_vtabptr_9pywrapfst__MutableSymbolTable = &__pyx_vtable_9pywrapfst__MutableSymbolTable; + __pyx_vtable_9pywrapfst__MutableSymbolTable.__pyx_base = *__pyx_vtabptr_9pywrapfst__SymbolTable; + __pyx_vtable_9pywrapfst__MutableSymbolTable.add_symbol = (__pyx_t_10basictypes_int64 (*)(struct __pyx_obj_9pywrapfst__MutableSymbolTable *, PyObject *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_19_MutableSymbolTable_add_symbol *__pyx_optional_args))__pyx_f_9pywrapfst_19_MutableSymbolTable_add_symbol; + __pyx_vtable_9pywrapfst__MutableSymbolTable.add_table = (void (*)(struct __pyx_obj_9pywrapfst__MutableSymbolTable *, struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_19_MutableSymbolTable_add_table; + __pyx_vtable_9pywrapfst__MutableSymbolTable.set_name = (void (*)(struct __pyx_obj_9pywrapfst__MutableSymbolTable *, PyObject *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_19_MutableSymbolTable_set_name; + __pyx_type_9pywrapfst__MutableSymbolTable.tp_base = __pyx_ptype_9pywrapfst__SymbolTable; + if (PyType_Ready(&__pyx_type_9pywrapfst__MutableSymbolTable) < 0) __PYX_ERR(0, 878, __pyx_L1_error) + __pyx_type_9pywrapfst__MutableSymbolTable.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_9pywrapfst__MutableSymbolTable.tp_dict, __pyx_vtabptr_9pywrapfst__MutableSymbolTable) < 0) __PYX_ERR(0, 878, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "_MutableSymbolTable", (PyObject *)&__pyx_type_9pywrapfst__MutableSymbolTable) < 0) __PYX_ERR(0, 878, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst__MutableSymbolTable) < 0) __PYX_ERR(0, 878, __pyx_L1_error) + __pyx_ptype_9pywrapfst__MutableSymbolTable = &__pyx_type_9pywrapfst__MutableSymbolTable; + __pyx_vtabptr_9pywrapfst__MutableFstSymbolTable = &__pyx_vtable_9pywrapfst__MutableFstSymbolTable; + __pyx_vtable_9pywrapfst__MutableFstSymbolTable.__pyx_base = *__pyx_vtabptr_9pywrapfst__MutableSymbolTable; + __pyx_type_9pywrapfst__MutableFstSymbolTable.tp_base = __pyx_ptype_9pywrapfst__MutableSymbolTable; + if (PyType_Ready(&__pyx_type_9pywrapfst__MutableFstSymbolTable) < 0) __PYX_ERR(0, 930, __pyx_L1_error) + __pyx_type_9pywrapfst__MutableFstSymbolTable.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_9pywrapfst__MutableFstSymbolTable.tp_dict, __pyx_vtabptr_9pywrapfst__MutableFstSymbolTable) < 0) __PYX_ERR(0, 930, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "_MutableFstSymbolTable", (PyObject *)&__pyx_type_9pywrapfst__MutableFstSymbolTable) < 0) __PYX_ERR(0, 930, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst__MutableFstSymbolTable) < 0) __PYX_ERR(0, 930, __pyx_L1_error) + __pyx_ptype_9pywrapfst__MutableFstSymbolTable = &__pyx_type_9pywrapfst__MutableFstSymbolTable; + __pyx_vtabptr_9pywrapfst_SymbolTable = &__pyx_vtable_9pywrapfst_SymbolTable; + __pyx_vtable_9pywrapfst_SymbolTable.__pyx_base = *__pyx_vtabptr_9pywrapfst__MutableSymbolTable; + __pyx_type_9pywrapfst_SymbolTable.tp_base = __pyx_ptype_9pywrapfst__MutableSymbolTable; + if (PyType_Ready(&__pyx_type_9pywrapfst_SymbolTable) < 0) __PYX_ERR(0, 941, __pyx_L1_error) + __pyx_type_9pywrapfst_SymbolTable.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_9pywrapfst_SymbolTable.tp_dict, __pyx_vtabptr_9pywrapfst_SymbolTable) < 0) __PYX_ERR(0, 941, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "SymbolTable", (PyObject *)&__pyx_type_9pywrapfst_SymbolTable) < 0) __PYX_ERR(0, 941, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst_SymbolTable) < 0) __PYX_ERR(0, 941, __pyx_L1_error) + __pyx_ptype_9pywrapfst_SymbolTable = &__pyx_type_9pywrapfst_SymbolTable; + __pyx_vtabptr_9pywrapfst_SymbolTableIterator = &__pyx_vtable_9pywrapfst_SymbolTableIterator; + __pyx_vtable_9pywrapfst_SymbolTableIterator.done = (bool (*)(struct __pyx_obj_9pywrapfst_SymbolTableIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_19SymbolTableIterator_done; + __pyx_vtable_9pywrapfst_SymbolTableIterator.next = (void (*)(struct __pyx_obj_9pywrapfst_SymbolTableIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_19SymbolTableIterator_next; + __pyx_vtable_9pywrapfst_SymbolTableIterator.reset = (void (*)(struct __pyx_obj_9pywrapfst_SymbolTableIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_19SymbolTableIterator_reset; + __pyx_vtable_9pywrapfst_SymbolTableIterator.symbol = (std::string (*)(struct __pyx_obj_9pywrapfst_SymbolTableIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_19SymbolTableIterator_symbol; + __pyx_vtable_9pywrapfst_SymbolTableIterator.value = (__pyx_t_10basictypes_int64 (*)(struct __pyx_obj_9pywrapfst_SymbolTableIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_19SymbolTableIterator_value; + if (PyType_Ready(&__pyx_type_9pywrapfst_SymbolTableIterator) < 0) __PYX_ERR(0, 1124, __pyx_L1_error) + __pyx_type_9pywrapfst_SymbolTableIterator.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_9pywrapfst_SymbolTableIterator.tp_dict, __pyx_vtabptr_9pywrapfst_SymbolTableIterator) < 0) __PYX_ERR(0, 1124, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "SymbolTableIterator", (PyObject *)&__pyx_type_9pywrapfst_SymbolTableIterator) < 0) __PYX_ERR(0, 1124, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst_SymbolTableIterator) < 0) __PYX_ERR(0, 1124, __pyx_L1_error) + __pyx_ptype_9pywrapfst_SymbolTableIterator = &__pyx_type_9pywrapfst_SymbolTableIterator; + __pyx_vtabptr_9pywrapfst_EncodeMapper = &__pyx_vtable_9pywrapfst_EncodeMapper; + __pyx_vtable_9pywrapfst_EncodeMapper.arc_type = (std::string (*)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12EncodeMapper_arc_type; + __pyx_vtable_9pywrapfst_EncodeMapper.flags = (__pyx_t_10basictypes_uint32 (*)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12EncodeMapper_flags; + __pyx_vtable_9pywrapfst_EncodeMapper.input_symbols = (struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *(*)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12EncodeMapper_input_symbols; + __pyx_vtable_9pywrapfst_EncodeMapper.output_symbols = (struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *(*)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12EncodeMapper_output_symbols; + __pyx_vtable_9pywrapfst_EncodeMapper.properties = (__pyx_t_10basictypes_uint64 (*)(struct __pyx_obj_9pywrapfst_EncodeMapper *, __pyx_t_10basictypes_uint64, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12EncodeMapper_properties; + __pyx_vtable_9pywrapfst_EncodeMapper.set_input_symbols = (void (*)(struct __pyx_obj_9pywrapfst_EncodeMapper *, struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12EncodeMapper_set_input_symbols; + __pyx_vtable_9pywrapfst_EncodeMapper.set_output_symbols = (void (*)(struct __pyx_obj_9pywrapfst_EncodeMapper *, struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12EncodeMapper_set_output_symbols; + __pyx_vtable_9pywrapfst_EncodeMapper.weight_type = (std::string (*)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12EncodeMapper_weight_type; + if (PyType_Ready(&__pyx_type_9pywrapfst_EncodeMapper) < 0) __PYX_ERR(0, 1206, __pyx_L1_error) + __pyx_type_9pywrapfst_EncodeMapper.tp_print = 0; + #if CYTHON_COMPILING_IN_CPYTHON + { + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_9pywrapfst_EncodeMapper, "__call__"); if (unlikely(!wrapper)) __PYX_ERR(0, 1206, __pyx_L1_error) + if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { + __pyx_wrapperbase_9pywrapfst_12EncodeMapper_6__call__ = *((PyWrapperDescrObject *)wrapper)->d_base; + __pyx_wrapperbase_9pywrapfst_12EncodeMapper_6__call__.doc = __pyx_doc_9pywrapfst_12EncodeMapper_6__call__; + ((PyWrapperDescrObject *)wrapper)->d_base = &__pyx_wrapperbase_9pywrapfst_12EncodeMapper_6__call__; + } + } + #endif + if (__Pyx_SetVtable(__pyx_type_9pywrapfst_EncodeMapper.tp_dict, __pyx_vtabptr_9pywrapfst_EncodeMapper) < 0) __PYX_ERR(0, 1206, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "EncodeMapper", (PyObject *)&__pyx_type_9pywrapfst_EncodeMapper) < 0) __PYX_ERR(0, 1206, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst_EncodeMapper) < 0) __PYX_ERR(0, 1206, __pyx_L1_error) + __pyx_ptype_9pywrapfst_EncodeMapper = &__pyx_type_9pywrapfst_EncodeMapper; + __pyx_vtabptr_9pywrapfst__Fst = &__pyx_vtable_9pywrapfst__Fst; + __pyx_vtable_9pywrapfst__Fst.arc_type = (std::string (*)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_arc_type; + __pyx_vtable_9pywrapfst__Fst.arcs = (struct __pyx_obj_9pywrapfst_ArcIterator *(*)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_arcs; + __pyx_vtable_9pywrapfst__Fst.copy = (struct __pyx_obj_9pywrapfst__Fst *(*)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_copy; + __pyx_vtable_9pywrapfst__Fst.draw = (void (*)(struct __pyx_obj_9pywrapfst__Fst *, PyObject *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_4_Fst_draw *__pyx_optional_args))__pyx_f_9pywrapfst_4_Fst_draw; + __pyx_vtable_9pywrapfst__Fst.final = (struct __pyx_obj_9pywrapfst_Weight *(*)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_final; + __pyx_vtable_9pywrapfst__Fst.fst_type = (std::string (*)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_fst_type; + __pyx_vtable_9pywrapfst__Fst.input_symbols = (struct __pyx_obj_9pywrapfst__FstSymbolTable *(*)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_input_symbols; + __pyx_vtable_9pywrapfst__Fst.num_arcs = (size_t (*)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_num_arcs; + __pyx_vtable_9pywrapfst__Fst.num_input_epsilons = (size_t (*)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_num_input_epsilons; + __pyx_vtable_9pywrapfst__Fst.num_output_epsilons = (size_t (*)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_num_output_epsilons; + __pyx_vtable_9pywrapfst__Fst.output_symbols = (struct __pyx_obj_9pywrapfst__FstSymbolTable *(*)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_output_symbols; + __pyx_vtable_9pywrapfst__Fst.properties = (__pyx_t_10basictypes_uint64 (*)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_uint64, bool, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_properties; + __pyx_vtable_9pywrapfst__Fst.start = (__pyx_t_10basictypes_int64 (*)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_start; + __pyx_vtable_9pywrapfst__Fst.states = (struct __pyx_obj_9pywrapfst_StateIterator *(*)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_states; + __pyx_vtable_9pywrapfst__Fst.text = (std::string (*)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_4_Fst_text *__pyx_optional_args))__pyx_f_9pywrapfst_4_Fst_text; + __pyx_vtable_9pywrapfst__Fst.verify = (bool (*)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_verify; + __pyx_vtable_9pywrapfst__Fst.weight_type = (std::string (*)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_weight_type; + __pyx_vtable_9pywrapfst__Fst.write = (void (*)(struct __pyx_obj_9pywrapfst__Fst *, PyObject *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_write; + __pyx_vtable_9pywrapfst__Fst.write_to_string = (std::string (*)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_write_to_string; + if (PyType_Ready(&__pyx_type_9pywrapfst__Fst) < 0) __PYX_ERR(0, 1362, __pyx_L1_error) + __pyx_type_9pywrapfst__Fst.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_9pywrapfst__Fst.tp_dict, __pyx_vtabptr_9pywrapfst__Fst) < 0) __PYX_ERR(0, 1362, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "_Fst", (PyObject *)&__pyx_type_9pywrapfst__Fst) < 0) __PYX_ERR(0, 1362, __pyx_L1_error) + __pyx_ptype_9pywrapfst__Fst = &__pyx_type_9pywrapfst__Fst; + __pyx_vtabptr_9pywrapfst__MutableFst = &__pyx_vtable_9pywrapfst__MutableFst; + __pyx_vtable_9pywrapfst__MutableFst.__pyx_base = *__pyx_vtabptr_9pywrapfst__Fst; + __pyx_vtable_9pywrapfst__MutableFst._check_mutating_imethod = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *))__pyx_f_9pywrapfst_11_MutableFst__check_mutating_imethod; + __pyx_vtable_9pywrapfst__MutableFst._add_arc = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64, struct __pyx_obj_9pywrapfst_Arc *))__pyx_f_9pywrapfst_11_MutableFst__add_arc; + __pyx_vtable_9pywrapfst__MutableFst.add_state = (__pyx_t_10basictypes_int64 (*)(struct __pyx_obj_9pywrapfst__MutableFst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_11_MutableFst_add_state; + __pyx_vtable_9pywrapfst__MutableFst._arcsort = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__arcsort *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__arcsort; + __pyx_vtable_9pywrapfst__MutableFst._closure = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__closure *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__closure; + __pyx_vtable_9pywrapfst__MutableFst._concat = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst__Fst *))__pyx_f_9pywrapfst_11_MutableFst__concat; + __pyx_vtable_9pywrapfst__MutableFst._connect = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *))__pyx_f_9pywrapfst_11_MutableFst__connect; + __pyx_vtable_9pywrapfst__MutableFst._decode = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst_EncodeMapper *))__pyx_f_9pywrapfst_11_MutableFst__decode; + __pyx_vtable_9pywrapfst__MutableFst._delete_arcs = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64, struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_arcs *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__delete_arcs; + __pyx_vtable_9pywrapfst__MutableFst._delete_states = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_states *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__delete_states; + __pyx_vtable_9pywrapfst__MutableFst._encode = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst_EncodeMapper *))__pyx_f_9pywrapfst_11_MutableFst__encode; + __pyx_vtable_9pywrapfst__MutableFst._invert = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *))__pyx_f_9pywrapfst_11_MutableFst__invert; + __pyx_vtable_9pywrapfst__MutableFst._minimize = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__minimize *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__minimize; + __pyx_vtable_9pywrapfst__MutableFst.mutable_arcs = (struct __pyx_obj_9pywrapfst_MutableArcIterator *(*)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_11_MutableFst_mutable_arcs; + __pyx_vtable_9pywrapfst__MutableFst.num_states = (__pyx_t_10basictypes_int64 (*)(struct __pyx_obj_9pywrapfst__MutableFst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_11_MutableFst_num_states; + __pyx_vtable_9pywrapfst__MutableFst._project = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__project *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__project; + __pyx_vtable_9pywrapfst__MutableFst._prune = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__prune *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__prune; + __pyx_vtable_9pywrapfst__MutableFst._push = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__push *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__push; + __pyx_vtable_9pywrapfst__MutableFst._relabel_pairs = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_pairs *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__relabel_pairs; + __pyx_vtable_9pywrapfst__MutableFst._relabel_tables = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_tables *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__relabel_tables; + __pyx_vtable_9pywrapfst__MutableFst._reserve_arcs = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64, size_t))__pyx_f_9pywrapfst_11_MutableFst__reserve_arcs; + __pyx_vtable_9pywrapfst__MutableFst._reserve_states = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64))__pyx_f_9pywrapfst_11_MutableFst__reserve_states; + __pyx_vtable_9pywrapfst__MutableFst._reweight = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, PyObject *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__reweight *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__reweight; + __pyx_vtable_9pywrapfst__MutableFst._rmepsilon = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__rmepsilon *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__rmepsilon; + __pyx_vtable_9pywrapfst__MutableFst._set_final = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64, struct __pyx_opt_args_9pywrapfst_11_MutableFst__set_final *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__set_final; + __pyx_vtable_9pywrapfst__MutableFst._set_properties = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_uint64, __pyx_t_10basictypes_uint64))__pyx_f_9pywrapfst_11_MutableFst__set_properties; + __pyx_vtable_9pywrapfst__MutableFst._set_start = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64))__pyx_f_9pywrapfst_11_MutableFst__set_start; + __pyx_vtable_9pywrapfst__MutableFst._set_input_symbols = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst__SymbolTable *))__pyx_f_9pywrapfst_11_MutableFst__set_input_symbols; + __pyx_vtable_9pywrapfst__MutableFst._set_output_symbols = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst__SymbolTable *))__pyx_f_9pywrapfst_11_MutableFst__set_output_symbols; + __pyx_vtable_9pywrapfst__MutableFst._topsort = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *))__pyx_f_9pywrapfst_11_MutableFst__topsort; + __pyx_vtable_9pywrapfst__MutableFst._union = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst__Fst *))__pyx_f_9pywrapfst_11_MutableFst__union; + __pyx_type_9pywrapfst__MutableFst.tp_base = __pyx_ptype_9pywrapfst__Fst; + if (PyType_Ready(&__pyx_type_9pywrapfst__MutableFst) < 0) __PYX_ERR(0, 1774, __pyx_L1_error) + __pyx_type_9pywrapfst__MutableFst.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_9pywrapfst__MutableFst.tp_dict, __pyx_vtabptr_9pywrapfst__MutableFst) < 0) __PYX_ERR(0, 1774, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "_MutableFst", (PyObject *)&__pyx_type_9pywrapfst__MutableFst) < 0) __PYX_ERR(0, 1774, __pyx_L1_error) + __pyx_ptype_9pywrapfst__MutableFst = &__pyx_type_9pywrapfst__MutableFst; + __pyx_vtabptr_9pywrapfst_Arc = &__pyx_vtable_9pywrapfst_Arc; + __pyx_vtable_9pywrapfst_Arc.copy = (struct __pyx_obj_9pywrapfst_Arc *(*)(struct __pyx_obj_9pywrapfst_Arc *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_3Arc_copy; + if (PyType_Ready(&__pyx_type_9pywrapfst_Arc) < 0) __PYX_ERR(0, 2898, __pyx_L1_error) + __pyx_type_9pywrapfst_Arc.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_9pywrapfst_Arc.tp_dict, __pyx_vtabptr_9pywrapfst_Arc) < 0) __PYX_ERR(0, 2898, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "Arc", (PyObject *)&__pyx_type_9pywrapfst_Arc) < 0) __PYX_ERR(0, 2898, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst_Arc) < 0) __PYX_ERR(0, 2898, __pyx_L1_error) + __pyx_ptype_9pywrapfst_Arc = &__pyx_type_9pywrapfst_Arc; + __pyx_vtabptr_9pywrapfst_ArcIterator = &__pyx_vtable_9pywrapfst_ArcIterator; + __pyx_vtable_9pywrapfst_ArcIterator.done = (bool (*)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_11ArcIterator_done; + __pyx_vtable_9pywrapfst_ArcIterator.flags = (__pyx_t_10basictypes_uint32 (*)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_11ArcIterator_flags; + __pyx_vtable_9pywrapfst_ArcIterator.next = (void (*)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_11ArcIterator_next; + __pyx_vtable_9pywrapfst_ArcIterator.position = (size_t (*)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_11ArcIterator_position; + __pyx_vtable_9pywrapfst_ArcIterator.reset = (void (*)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_11ArcIterator_reset; + __pyx_vtable_9pywrapfst_ArcIterator.seek = (void (*)(struct __pyx_obj_9pywrapfst_ArcIterator *, size_t, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_11ArcIterator_seek; + __pyx_vtable_9pywrapfst_ArcIterator.set_flags = (void (*)(struct __pyx_obj_9pywrapfst_ArcIterator *, __pyx_t_10basictypes_uint32, __pyx_t_10basictypes_uint32, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_11ArcIterator_set_flags; + __pyx_vtable_9pywrapfst_ArcIterator.value = (PyObject *(*)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_11ArcIterator_value; + if (PyType_Ready(&__pyx_type_9pywrapfst_ArcIterator) < 0) __PYX_ERR(0, 2965, __pyx_L1_error) + __pyx_type_9pywrapfst_ArcIterator.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_9pywrapfst_ArcIterator.tp_dict, __pyx_vtabptr_9pywrapfst_ArcIterator) < 0) __PYX_ERR(0, 2965, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "ArcIterator", (PyObject *)&__pyx_type_9pywrapfst_ArcIterator) < 0) __PYX_ERR(0, 2965, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst_ArcIterator) < 0) __PYX_ERR(0, 2965, __pyx_L1_error) + __pyx_ptype_9pywrapfst_ArcIterator = &__pyx_type_9pywrapfst_ArcIterator; + __pyx_vtabptr_9pywrapfst_MutableArcIterator = &__pyx_vtable_9pywrapfst_MutableArcIterator; + __pyx_vtable_9pywrapfst_MutableArcIterator.done = (bool (*)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_18MutableArcIterator_done; + __pyx_vtable_9pywrapfst_MutableArcIterator.flags = (__pyx_t_10basictypes_uint32 (*)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_18MutableArcIterator_flags; + __pyx_vtable_9pywrapfst_MutableArcIterator.next = (void (*)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_18MutableArcIterator_next; + __pyx_vtable_9pywrapfst_MutableArcIterator.position = (size_t (*)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_18MutableArcIterator_position; + __pyx_vtable_9pywrapfst_MutableArcIterator.reset = (void (*)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_18MutableArcIterator_reset; + __pyx_vtable_9pywrapfst_MutableArcIterator.seek = (void (*)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, size_t, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_18MutableArcIterator_seek; + __pyx_vtable_9pywrapfst_MutableArcIterator.set_flags = (void (*)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, __pyx_t_10basictypes_uint32, __pyx_t_10basictypes_uint32, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_18MutableArcIterator_set_flags; + __pyx_vtable_9pywrapfst_MutableArcIterator.set_value = (void (*)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, struct __pyx_obj_9pywrapfst_Arc *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_18MutableArcIterator_set_value; + __pyx_vtable_9pywrapfst_MutableArcIterator.value = (PyObject *(*)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_18MutableArcIterator_value; + if (PyType_Ready(&__pyx_type_9pywrapfst_MutableArcIterator) < 0) __PYX_ERR(0, 3076, __pyx_L1_error) + __pyx_type_9pywrapfst_MutableArcIterator.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_9pywrapfst_MutableArcIterator.tp_dict, __pyx_vtabptr_9pywrapfst_MutableArcIterator) < 0) __PYX_ERR(0, 3076, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "MutableArcIterator", (PyObject *)&__pyx_type_9pywrapfst_MutableArcIterator) < 0) __PYX_ERR(0, 3076, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst_MutableArcIterator) < 0) __PYX_ERR(0, 3076, __pyx_L1_error) + __pyx_ptype_9pywrapfst_MutableArcIterator = &__pyx_type_9pywrapfst_MutableArcIterator; + __pyx_vtabptr_9pywrapfst_StateIterator = &__pyx_vtable_9pywrapfst_StateIterator; + __pyx_vtable_9pywrapfst_StateIterator.done = (bool (*)(struct __pyx_obj_9pywrapfst_StateIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_13StateIterator_done; + __pyx_vtable_9pywrapfst_StateIterator.next = (void (*)(struct __pyx_obj_9pywrapfst_StateIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_13StateIterator_next; + __pyx_vtable_9pywrapfst_StateIterator.reset = (void (*)(struct __pyx_obj_9pywrapfst_StateIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_13StateIterator_reset; + __pyx_vtable_9pywrapfst_StateIterator.value = (__pyx_t_10basictypes_int64 (*)(struct __pyx_obj_9pywrapfst_StateIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_13StateIterator_value; + if (PyType_Ready(&__pyx_type_9pywrapfst_StateIterator) < 0) __PYX_ERR(0, 3190, __pyx_L1_error) + __pyx_type_9pywrapfst_StateIterator.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_9pywrapfst_StateIterator.tp_dict, __pyx_vtabptr_9pywrapfst_StateIterator) < 0) __PYX_ERR(0, 3190, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "StateIterator", (PyObject *)&__pyx_type_9pywrapfst_StateIterator) < 0) __PYX_ERR(0, 3190, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst_StateIterator) < 0) __PYX_ERR(0, 3190, __pyx_L1_error) + __pyx_ptype_9pywrapfst_StateIterator = &__pyx_type_9pywrapfst_StateIterator; + __pyx_vtabptr_9pywrapfst_Compiler = &__pyx_vtable_9pywrapfst_Compiler; + __pyx_vtable_9pywrapfst_Compiler.compile = (struct __pyx_obj_9pywrapfst__Fst *(*)(struct __pyx_obj_9pywrapfst_Compiler *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_8Compiler_compile; + __pyx_vtable_9pywrapfst_Compiler.write = (void (*)(struct __pyx_obj_9pywrapfst_Compiler *, PyObject *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_8Compiler_write; + if (PyType_Ready(&__pyx_type_9pywrapfst_Compiler) < 0) __PYX_ERR(0, 4088, __pyx_L1_error) + __pyx_type_9pywrapfst_Compiler.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_9pywrapfst_Compiler.tp_dict, __pyx_vtabptr_9pywrapfst_Compiler) < 0) __PYX_ERR(0, 4088, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "Compiler", (PyObject *)&__pyx_type_9pywrapfst_Compiler) < 0) __PYX_ERR(0, 4088, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst_Compiler) < 0) __PYX_ERR(0, 4088, __pyx_L1_error) + __pyx_ptype_9pywrapfst_Compiler = &__pyx_type_9pywrapfst_Compiler; + __pyx_vtabptr_9pywrapfst_FarReader = &__pyx_vtable_9pywrapfst_FarReader; + __pyx_vtable_9pywrapfst_FarReader.arc_type = (std::string (*)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_9FarReader_arc_type; + __pyx_vtable_9pywrapfst_FarReader.done = (bool (*)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_9FarReader_done; + __pyx_vtable_9pywrapfst_FarReader.error = (bool (*)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_9FarReader_error; + __pyx_vtable_9pywrapfst_FarReader.far_type = (std::string (*)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_9FarReader_far_type; + __pyx_vtable_9pywrapfst_FarReader.find = (bool (*)(struct __pyx_obj_9pywrapfst_FarReader *, PyObject *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_9FarReader_find; + __pyx_vtable_9pywrapfst_FarReader.get_fst = (struct __pyx_obj_9pywrapfst__Fst *(*)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_9FarReader_get_fst; + __pyx_vtable_9pywrapfst_FarReader.get_key = (std::string (*)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_9FarReader_get_key; + __pyx_vtable_9pywrapfst_FarReader.next = (void (*)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_9FarReader_next; + __pyx_vtable_9pywrapfst_FarReader.reset = (void (*)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_9FarReader_reset; + if (PyType_Ready(&__pyx_type_9pywrapfst_FarReader) < 0) __PYX_ERR(0, 4215, __pyx_L1_error) + __pyx_type_9pywrapfst_FarReader.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_9pywrapfst_FarReader.tp_dict, __pyx_vtabptr_9pywrapfst_FarReader) < 0) __PYX_ERR(0, 4215, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "FarReader", (PyObject *)&__pyx_type_9pywrapfst_FarReader) < 0) __PYX_ERR(0, 4215, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst_FarReader) < 0) __PYX_ERR(0, 4215, __pyx_L1_error) + __pyx_ptype_9pywrapfst_FarReader = &__pyx_type_9pywrapfst_FarReader; + __pyx_vtabptr_9pywrapfst_FarWriter = &__pyx_vtable_9pywrapfst_FarWriter; + __pyx_vtable_9pywrapfst_FarWriter.arc_type = (std::string (*)(struct __pyx_obj_9pywrapfst_FarWriter *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_9FarWriter_arc_type; + __pyx_vtable_9pywrapfst_FarWriter.close = (void (*)(struct __pyx_obj_9pywrapfst_FarWriter *))__pyx_f_9pywrapfst_9FarWriter_close; + __pyx_vtable_9pywrapfst_FarWriter.add = (void (*)(struct __pyx_obj_9pywrapfst_FarWriter *, PyObject *, struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_9FarWriter_add; + __pyx_vtable_9pywrapfst_FarWriter.error = (bool (*)(struct __pyx_obj_9pywrapfst_FarWriter *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_9FarWriter_error; + __pyx_vtable_9pywrapfst_FarWriter.far_type = (std::string (*)(struct __pyx_obj_9pywrapfst_FarWriter *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_9FarWriter_far_type; + if (PyType_Ready(&__pyx_type_9pywrapfst_FarWriter) < 0) __PYX_ERR(0, 4360, __pyx_L1_error) + __pyx_type_9pywrapfst_FarWriter.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_9pywrapfst_FarWriter.tp_dict, __pyx_vtabptr_9pywrapfst_FarWriter) < 0) __PYX_ERR(0, 4360, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "FarWriter", (PyObject *)&__pyx_type_9pywrapfst_FarWriter) < 0) __PYX_ERR(0, 4360, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst_FarWriter) < 0) __PYX_ERR(0, 4360, __pyx_L1_error) + __pyx_ptype_9pywrapfst_FarWriter = &__pyx_type_9pywrapfst_FarWriter; + /*--- Type import code ---*/ + /*--- Variable import code ---*/ + /*--- Function import code ---*/ + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + + /* "pywrapfst.pyx":107 + * + * # Python imports. + * import atexit # <<<<<<<<<<<<<< + * import numbers + * import subprocess + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_atexit, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_atexit, __pyx_t_1) < 0) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":108 + * # Python imports. + * import atexit + * import numbers # <<<<<<<<<<<<<< + * import subprocess + * import logging + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_numbers, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_numbers, __pyx_t_1) < 0) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":109 + * import atexit + * import numbers + * import subprocess # <<<<<<<<<<<<<< + * import logging + * + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_subprocess, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_subprocess, __pyx_t_1) < 0) __PYX_ERR(0, 109, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":110 + * import numbers + * import subprocess + * import logging # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_logging, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_logging, __pyx_t_1) < 0) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":115 + * # TODO(kbg): Figure out how to access static class variables so I don't have + * # to do it this way. + * kNoSymbol = -1 # <<<<<<<<<<<<<< + * + * + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_kNoSymbol, __pyx_int_neg_1) < 0) __PYX_ERR(0, 115, __pyx_L1_error) + + /* "pywrapfst.pyx":121 + * + * + * class FstError(Exception): # <<<<<<<<<<<<<< + * + * pass + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + __Pyx_GIVEREF(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_FstError, __pyx_n_s_FstError, (PyObject *) NULL, __pyx_n_s_pywrapfst_2, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_FstError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_FstError, __pyx_t_4) < 0) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":126 + * + * + * class FstArgError(FstError, ValueError): # <<<<<<<<<<<<<< + * + * pass + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + __Pyx_INCREF(__pyx_builtin_ValueError); + __Pyx_GIVEREF(__pyx_builtin_ValueError); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_builtin_ValueError); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_FstArgError, __pyx_n_s_FstArgError, (PyObject *) NULL, __pyx_n_s_pywrapfst_2, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_FstArgError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_FstArgError, __pyx_t_4) < 0) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "pywrapfst.pyx":131 + * + * + * class FstBadWeightError(FstError, ValueError): # <<<<<<<<<<<<<< + * + * pass + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_builtin_ValueError); + __Pyx_GIVEREF(__pyx_builtin_ValueError); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_builtin_ValueError); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_FstBadWeightError, __pyx_n_s_FstBadWeightError, (PyObject *) NULL, __pyx_n_s_pywrapfst_2, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_FstBadWeightError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_FstBadWeightError, __pyx_t_4) < 0) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":136 + * + * + * class FstDeletedConstructorError(FstError, RuntimeError): # <<<<<<<<<<<<<< + * + * pass + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + __Pyx_INCREF(__pyx_builtin_RuntimeError); + __Pyx_GIVEREF(__pyx_builtin_RuntimeError); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_builtin_RuntimeError); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_FstDeletedConstructorError, __pyx_n_s_FstDeletedConstructorError, (PyObject *) NULL, __pyx_n_s_pywrapfst_2, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_FstDeletedConstructorError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_FstDeletedConstructorError, __pyx_t_4) < 0) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "pywrapfst.pyx":141 + * + * + * class FstIndexError(FstError, IndexError): # <<<<<<<<<<<<<< + * + * pass + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_builtin_IndexError); + __Pyx_GIVEREF(__pyx_builtin_IndexError); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_builtin_IndexError); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_FstIndexError, __pyx_n_s_FstIndexError, (PyObject *) NULL, __pyx_n_s_pywrapfst_2, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_FstIndexError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_FstIndexError, __pyx_t_4) < 0) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":146 + * + * + * class FstIOError(FstError, IOError): # <<<<<<<<<<<<<< + * + * pass + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + __Pyx_INCREF(__pyx_builtin_IOError); + __Pyx_GIVEREF(__pyx_builtin_IOError); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_builtin_IOError); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_FstIOError, __pyx_n_s_FstIOError, (PyObject *) NULL, __pyx_n_s_pywrapfst_2, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_FstIOError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_FstIOError, __pyx_t_4) < 0) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "pywrapfst.pyx":151 + * + * + * class FstOpError(FstError, RuntimeError): # <<<<<<<<<<<<<< + * + * pass + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_builtin_RuntimeError); + __Pyx_GIVEREF(__pyx_builtin_RuntimeError); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_builtin_RuntimeError); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_FstOpError, __pyx_n_s_FstOpError, (PyObject *) NULL, __pyx_n_s_pywrapfst_2, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_FstOpError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_FstOpError, __pyx_t_4) < 0) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":406 + * + * @classmethod + * def Zero(cls, weight_type): # <<<<<<<<<<<<<< + * """ + * Weight.Zero(weight_type) + */ + __pyx_t_1 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_9pywrapfst_Weight, __pyx_n_s_Zero); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 406, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "pywrapfst.pyx":405 + * # C++ part out-of-class and then call it from within. + * + * @classmethod # <<<<<<<<<<<<<< + * def Zero(cls, weight_type): + * """ + */ + __pyx_t_2 = __Pyx_Method_ClassMethod(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (PyDict_SetItem((PyObject *)__pyx_ptype_9pywrapfst_Weight->tp_dict, __pyx_n_s_Zero, __pyx_t_2) < 0) __PYX_ERR(0, 406, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_9pywrapfst_Weight); + + /* "pywrapfst.pyx":415 + * + * @classmethod + * def One(cls, weight_type): # <<<<<<<<<<<<<< + * """ + * Weight.One(weight_type) + */ + __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_9pywrapfst_Weight, __pyx_n_s_One); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 415, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "pywrapfst.pyx":414 + * return _Zero(weight_type) + * + * @classmethod # <<<<<<<<<<<<<< + * def One(cls, weight_type): + * """ + */ + __pyx_t_1 = __Pyx_Method_ClassMethod(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem((PyObject *)__pyx_ptype_9pywrapfst_Weight->tp_dict, __pyx_n_s_One, __pyx_t_1) < 0) __PYX_ERR(0, 415, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_ptype_9pywrapfst_Weight); + + /* "pywrapfst.pyx":424 + * + * @classmethod + * def NoWeight(cls, weight_type): # <<<<<<<<<<<<<< + * """ + * Weight.NoWeight(weight_type) + */ + __pyx_t_1 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_9pywrapfst_Weight, __pyx_n_s_NoWeight); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "pywrapfst.pyx":423 + * return _One(weight_type) + * + * @classmethod # <<<<<<<<<<<<<< + * def NoWeight(cls, weight_type): + * """ + */ + __pyx_t_2 = __Pyx_Method_ClassMethod(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (PyDict_SetItem((PyObject *)__pyx_ptype_9pywrapfst_Weight->tp_dict, __pyx_n_s_NoWeight, __pyx_t_2) < 0) __PYX_ERR(0, 424, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_9pywrapfst_Weight); + + /* "pywrapfst.pyx":456 + * + * + * def plus(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< + * """ + * plus(lhs, rhs) + */ + __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_9pywrapfst_1plus, NULL, __pyx_n_s_pywrapfst_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 456, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_plus, __pyx_t_2) < 0) __PYX_ERR(0, 456, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "pywrapfst.pyx":488 + * + * + * def times(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< + * """ + * times(lhs, rhs) + */ + __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_9pywrapfst_3times, NULL, __pyx_n_s_pywrapfst_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 488, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_times, __pyx_t_2) < 0) __PYX_ERR(0, 488, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "pywrapfst.pyx":520 + * + * + * def divide(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< + * """ + * divide(lhs, rhs) + */ + __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_9pywrapfst_5divide, NULL, __pyx_n_s_pywrapfst_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 520, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_divide, __pyx_t_2) < 0) __PYX_ERR(0, 520, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "pywrapfst.pyx":553 + * + * + * def power(Weight w, size_t n): # <<<<<<<<<<<<<< + * """ + * power(lhs, rhs) + */ + __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_9pywrapfst_7power, NULL, __pyx_n_s_pywrapfst_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 553, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_power, __pyx_t_2) < 0) __PYX_ERR(0, 553, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "pywrapfst.pyx":889 + * """ + * + * cpdef int64 add_symbol(self, symbol, int64 key=kNoSymbol): # <<<<<<<<<<<<<< + * """ + * add_symbol(self, symbol, key=NO_SYMBOL) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_kNoSymbol); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 889, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 889, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_k__13 = __pyx_t_5; + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_kNoSymbol); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 889, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 889, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_k__13 = __pyx_t_5; + + /* "pywrapfst.pyx":966 + * + * @classmethod + * def read(cls, filename): # <<<<<<<<<<<<<< + * """ + * SymbolTable.read(filename) + */ + __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_9pywrapfst_SymbolTable, __pyx_n_s_read); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 966, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "pywrapfst.pyx":965 + * self._smart_table.reset(self._table) + * + * @classmethod # <<<<<<<<<<<<<< + * def read(cls, filename): + * """ + */ + __pyx_t_1 = __Pyx_Method_ClassMethod(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 965, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem((PyObject *)__pyx_ptype_9pywrapfst_SymbolTable->tp_dict, __pyx_n_s_read, __pyx_t_1) < 0) __PYX_ERR(0, 966, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_ptype_9pywrapfst_SymbolTable); + + /* "pywrapfst.pyx":988 + * + * @classmethod + * def read_text(cls, filename, bool allow_negative_labels=False): # <<<<<<<<<<<<<< + * """ + * SymbolTable.read_text(filename) + */ + __pyx_t_1 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_9pywrapfst_SymbolTable, __pyx_n_s_read_text); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 988, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "pywrapfst.pyx":987 + * return _init_SymbolTable(tsyms) + * + * @classmethod # <<<<<<<<<<<<<< + * def read_text(cls, filename, bool allow_negative_labels=False): + * """ + */ + __pyx_t_2 = __Pyx_Method_ClassMethod(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 987, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (PyDict_SetItem((PyObject *)__pyx_ptype_9pywrapfst_SymbolTable->tp_dict, __pyx_n_s_read_text, __pyx_t_2) < 0) __PYX_ERR(0, 988, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_9pywrapfst_SymbolTable); + + /* "pywrapfst.pyx":1015 + * + * @classmethod + * def read_fst(cls, filename, bool input_table): # <<<<<<<<<<<<<< + * """ + * SymbolTable.read_fst(filename, input_table) + */ + __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_9pywrapfst_SymbolTable, __pyx_n_s_read_fst); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1015, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "pywrapfst.pyx":1014 + * return _init_SymbolTable(tsyms) + * + * @classmethod # <<<<<<<<<<<<<< + * def read_fst(cls, filename, bool input_table): + * """ + */ + __pyx_t_1 = __Pyx_Method_ClassMethod(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1014, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem((PyObject *)__pyx_ptype_9pywrapfst_SymbolTable->tp_dict, __pyx_n_s_read_fst, __pyx_t_1) < 0) __PYX_ERR(0, 1015, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_ptype_9pywrapfst_SymbolTable); + + /* "pywrapfst.pyx":2064 + * return self + * + * cdef void _minimize(self, float delta=fst.kShortestDelta, # <<<<<<<<<<<<<< + * bool allow_nondet=False) except *: + * # This runs in-place when the second argument is null. + */ + __pyx_k__35 = fst::kShortestDelta; + + /* "pywrapfst.pyx":2070 + * self._check_mutating_imethod() + * + * def minimize(self, float delta=fst.kShortestDelta, bool allow_nondet=False): # <<<<<<<<<<<<<< + * """ + * minimize(self, delta=1e-6, allow_nondet=False) + */ + __pyx_k__36 = fst::kShortestDelta; + + /* "pywrapfst.pyx":2170 + * return self + * + * cdef void _prune(self, float delta=fst.kDelta, int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< + * weight=None) except *: + * # Threshold is set to semiring Zero (no pruning) if no weight is specified. + */ + __pyx_k__37 = fst::kDelta; + __pyx_k__38 = fst::kNoStateId; + + /* "pywrapfst.pyx":2179 + * + * def prune(self, + * float delta=fst.kDelta, # <<<<<<<<<<<<<< + * int64 nstate=fst.kNoStateId, + * weight=None): + */ + __pyx_k__39 = fst::kDelta; + + /* "pywrapfst.pyx":2180 + * def prune(self, + * float delta=fst.kDelta, + * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< + * weight=None): + * """ + */ + __pyx_k__40 = fst::kNoStateId; + + /* "pywrapfst.pyx":2207 + * + * cdef void _push(self, + * float delta=fst.kDelta, # <<<<<<<<<<<<<< + * bool remove_total_weight=False, + * bool to_final=False) except *: + */ + __pyx_k__41 = fst::kDelta; + + /* "pywrapfst.pyx":2215 + * + * def push(self, + * float delta=fst.kDelta, # <<<<<<<<<<<<<< + * bool remove_total_weight=False, + * bool to_final=False): + */ + __pyx_k__42 = fst::kDelta; + + /* "pywrapfst.pyx":2452 + * bool connect=True, + * weight=None, + * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< + * float delta=fst.kShortestDelta) except *: + * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(self.weight_type(), + */ + __pyx_k__46 = fst::kNoStateId; + + /* "pywrapfst.pyx":2453 + * weight=None, + * int64 nstate=fst.kNoStateId, + * float delta=fst.kShortestDelta) except *: # <<<<<<<<<<<<<< + * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(self.weight_type(), + * weight) + */ + __pyx_k__47 = fst::kShortestDelta; + + /* "pywrapfst.pyx":2466 + * bool connect=True, + * weight=None, + * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< + * float delta=fst.kShortestDelta): + * """ + */ + __pyx_k__48 = fst::kNoStateId; + + /* "pywrapfst.pyx":2467 + * weight=None, + * int64 nstate=fst.kNoStateId, + * float delta=fst.kShortestDelta): # <<<<<<<<<<<<<< + * """ + * rmepsilon(self, queue_type="auto", connect=True, weight=None, + */ + __pyx_k__49 = fst::kShortestDelta; + + /* "pywrapfst.pyx":2742 + * + * + * class Fst(object): # <<<<<<<<<<<<<< + * + * """ + */ + __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__107); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2742, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_tuple__107, __pyx_n_s_Fst, __pyx_n_s_Fst, (PyObject *) NULL, __pyx_n_s_pywrapfst_2, __pyx_kp_s_Fst_arc_type_standard_Construct); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2742, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "pywrapfst.pyx":2759 + * """ + * + * def __new__(cls, arc_type=b"standard"): # <<<<<<<<<<<<<< + * return _create_Fst(arc_type) + * + */ + __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9pywrapfst_3Fst_1__new__, __Pyx_CYFUNCTION_STATICMETHOD, __pyx_n_s_Fst___new, NULL, __pyx_n_s_pywrapfst_2, __pyx_d, ((PyObject *)__pyx_codeobj__109)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2759, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__110); + if (PyObject_SetItem(__pyx_t_2, __pyx_n_s_new, __pyx_t_3) < 0) __PYX_ERR(0, 2759, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "pywrapfst.pyx":2763 + * + * @staticmethod + * def read(filename): # <<<<<<<<<<<<<< + * """ + * read(filename): + */ + __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9pywrapfst_3Fst_3read, __Pyx_CYFUNCTION_STATICMETHOD, __pyx_n_s_Fst_read, NULL, __pyx_n_s_pywrapfst_2, __pyx_d, ((PyObject *)__pyx_codeobj__112)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2763, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "pywrapfst.pyx":2762 + * return _create_Fst(arc_type) + * + * @staticmethod # <<<<<<<<<<<<<< + * def read(filename): + * """ + */ + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2762, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_staticmethod, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2762, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyObject_SetItem(__pyx_t_2, __pyx_n_s_read, __pyx_t_3) < 0) __PYX_ERR(0, 2763, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "pywrapfst.pyx":2781 + * + * @staticmethod + * def read_from_string(state): # <<<<<<<<<<<<<< + * """ + * read_from_string(string, fst_type=None) + */ + __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9pywrapfst_3Fst_5read_from_string, __Pyx_CYFUNCTION_STATICMETHOD, __pyx_n_s_Fst_read_from_string, NULL, __pyx_n_s_pywrapfst_2, __pyx_d, ((PyObject *)__pyx_codeobj__114)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2781, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "pywrapfst.pyx":2780 + * return _read(filename) + * + * @staticmethod # <<<<<<<<<<<<<< + * def read_from_string(state): + * """ + */ + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2780, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_staticmethod, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2780, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyObject_SetItem(__pyx_t_2, __pyx_n_s_read_from_string_2, __pyx_t_3) < 0) __PYX_ERR(0, 2781, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "pywrapfst.pyx":2742 + * + * + * class Fst(object): # <<<<<<<<<<<<<< + * + * """ + */ + __pyx_t_3 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_Fst, __pyx_tuple__107, __pyx_t_2, NULL, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2742, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Fst, __pyx_t_3) < 0) __PYX_ERR(0, 2742, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2805 + * + * + * NO_LABEL = fst.kNoLabel # <<<<<<<<<<<<<< + * NO_STATE_ID = fst.kNoStateId + * # TODO(kbg): Figure out how to access static class variables so I don't have + */ + __pyx_t_1 = __Pyx_PyInt_From_int(fst::kNoLabel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2805, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_NO_LABEL, __pyx_t_1) < 0) __PYX_ERR(0, 2805, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2806 + * + * NO_LABEL = fst.kNoLabel + * NO_STATE_ID = fst.kNoStateId # <<<<<<<<<<<<<< + * # TODO(kbg): Figure out how to access static class variables so I don't have + * # to do it this way. + */ + __pyx_t_1 = __Pyx_PyInt_From_int(fst::kNoStateId); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2806, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_NO_STATE_ID, __pyx_t_1) < 0) __PYX_ERR(0, 2806, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2809 + * # TODO(kbg): Figure out how to access static class variables so I don't have + * # to do it this way. + * NO_SYMBOL = kNoSymbol # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_kNoSymbol); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2809, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_NO_SYMBOL, __pyx_t_1) < 0) __PYX_ERR(0, 2809, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2815 + * + * + * EXPANDED = fst.kExpanded # <<<<<<<<<<<<<< + * MUTABLE = fst.kMutable + * ERROR = fst.kError + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kExpanded); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2815, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_EXPANDED, __pyx_t_1) < 0) __PYX_ERR(0, 2815, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2816 + * + * EXPANDED = fst.kExpanded + * MUTABLE = fst.kMutable # <<<<<<<<<<<<<< + * ERROR = fst.kError + * ACCEPTOR = fst.kAcceptor + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kMutable); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2816, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_MUTABLE, __pyx_t_1) < 0) __PYX_ERR(0, 2816, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2817 + * EXPANDED = fst.kExpanded + * MUTABLE = fst.kMutable + * ERROR = fst.kError # <<<<<<<<<<<<<< + * ACCEPTOR = fst.kAcceptor + * NOT_ACCEPTOR = fst.kNotAcceptor + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2817, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERROR, __pyx_t_1) < 0) __PYX_ERR(0, 2817, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2818 + * MUTABLE = fst.kMutable + * ERROR = fst.kError + * ACCEPTOR = fst.kAcceptor # <<<<<<<<<<<<<< + * NOT_ACCEPTOR = fst.kNotAcceptor + * I_DETERMINISTIC = fst.kIDeterministic + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kAcceptor); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2818, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ACCEPTOR, __pyx_t_1) < 0) __PYX_ERR(0, 2818, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2819 + * ERROR = fst.kError + * ACCEPTOR = fst.kAcceptor + * NOT_ACCEPTOR = fst.kNotAcceptor # <<<<<<<<<<<<<< + * I_DETERMINISTIC = fst.kIDeterministic + * NON_I_DETERMINISTIC = fst.kNonIDeterministic + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kNotAcceptor); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2819, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_NOT_ACCEPTOR, __pyx_t_1) < 0) __PYX_ERR(0, 2819, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2820 + * ACCEPTOR = fst.kAcceptor + * NOT_ACCEPTOR = fst.kNotAcceptor + * I_DETERMINISTIC = fst.kIDeterministic # <<<<<<<<<<<<<< + * NON_I_DETERMINISTIC = fst.kNonIDeterministic + * O_DETERMINISTIC = fst.kODeterministic + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kIDeterministic); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2820, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_I_DETERMINISTIC, __pyx_t_1) < 0) __PYX_ERR(0, 2820, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2821 + * NOT_ACCEPTOR = fst.kNotAcceptor + * I_DETERMINISTIC = fst.kIDeterministic + * NON_I_DETERMINISTIC = fst.kNonIDeterministic # <<<<<<<<<<<<<< + * O_DETERMINISTIC = fst.kODeterministic + * NON_O_DETERMINISTIC = fst.kNonODeterministic + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kNonIDeterministic); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2821, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_NON_I_DETERMINISTIC, __pyx_t_1) < 0) __PYX_ERR(0, 2821, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2822 + * I_DETERMINISTIC = fst.kIDeterministic + * NON_I_DETERMINISTIC = fst.kNonIDeterministic + * O_DETERMINISTIC = fst.kODeterministic # <<<<<<<<<<<<<< + * NON_O_DETERMINISTIC = fst.kNonODeterministic + * EPSILONS = fst.kEpsilons + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kODeterministic); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2822, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_O_DETERMINISTIC, __pyx_t_1) < 0) __PYX_ERR(0, 2822, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2823 + * NON_I_DETERMINISTIC = fst.kNonIDeterministic + * O_DETERMINISTIC = fst.kODeterministic + * NON_O_DETERMINISTIC = fst.kNonODeterministic # <<<<<<<<<<<<<< + * EPSILONS = fst.kEpsilons + * NO_EPSILONS = fst.kNoEpsilons + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kNonODeterministic); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2823, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_NON_O_DETERMINISTIC, __pyx_t_1) < 0) __PYX_ERR(0, 2823, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2824 + * O_DETERMINISTIC = fst.kODeterministic + * NON_O_DETERMINISTIC = fst.kNonODeterministic + * EPSILONS = fst.kEpsilons # <<<<<<<<<<<<<< + * NO_EPSILONS = fst.kNoEpsilons + * I_EPSILONS = fst.kIEpsilons + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kEpsilons); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2824, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_EPSILONS, __pyx_t_1) < 0) __PYX_ERR(0, 2824, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2825 + * NON_O_DETERMINISTIC = fst.kNonODeterministic + * EPSILONS = fst.kEpsilons + * NO_EPSILONS = fst.kNoEpsilons # <<<<<<<<<<<<<< + * I_EPSILONS = fst.kIEpsilons + * NO_I_EPSILONS = fst.kNoIEpsilons + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kNoEpsilons); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2825, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_NO_EPSILONS, __pyx_t_1) < 0) __PYX_ERR(0, 2825, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2826 + * EPSILONS = fst.kEpsilons + * NO_EPSILONS = fst.kNoEpsilons + * I_EPSILONS = fst.kIEpsilons # <<<<<<<<<<<<<< + * NO_I_EPSILONS = fst.kNoIEpsilons + * O_EPSILONS = fst.kOEpsilons + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kIEpsilons); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2826, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_I_EPSILONS, __pyx_t_1) < 0) __PYX_ERR(0, 2826, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2827 + * NO_EPSILONS = fst.kNoEpsilons + * I_EPSILONS = fst.kIEpsilons + * NO_I_EPSILONS = fst.kNoIEpsilons # <<<<<<<<<<<<<< + * O_EPSILONS = fst.kOEpsilons + * NO_O_EPSILONS = fst.kNoOEpsilons + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kNoIEpsilons); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2827, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_NO_I_EPSILONS, __pyx_t_1) < 0) __PYX_ERR(0, 2827, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2828 + * I_EPSILONS = fst.kIEpsilons + * NO_I_EPSILONS = fst.kNoIEpsilons + * O_EPSILONS = fst.kOEpsilons # <<<<<<<<<<<<<< + * NO_O_EPSILONS = fst.kNoOEpsilons + * I_LABEL_SORTED = fst.kILabelSorted + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kOEpsilons); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2828, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_O_EPSILONS, __pyx_t_1) < 0) __PYX_ERR(0, 2828, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2829 + * NO_I_EPSILONS = fst.kNoIEpsilons + * O_EPSILONS = fst.kOEpsilons + * NO_O_EPSILONS = fst.kNoOEpsilons # <<<<<<<<<<<<<< + * I_LABEL_SORTED = fst.kILabelSorted + * NOT_I_LABEL_SORTED = fst.kNotILabelSorted + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kNoOEpsilons); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2829, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_NO_O_EPSILONS, __pyx_t_1) < 0) __PYX_ERR(0, 2829, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2830 + * O_EPSILONS = fst.kOEpsilons + * NO_O_EPSILONS = fst.kNoOEpsilons + * I_LABEL_SORTED = fst.kILabelSorted # <<<<<<<<<<<<<< + * NOT_I_LABEL_SORTED = fst.kNotILabelSorted + * O_LABEL_SORTED = fst.kOLabelSorted + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kILabelSorted); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2830, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_I_LABEL_SORTED, __pyx_t_1) < 0) __PYX_ERR(0, 2830, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2831 + * NO_O_EPSILONS = fst.kNoOEpsilons + * I_LABEL_SORTED = fst.kILabelSorted + * NOT_I_LABEL_SORTED = fst.kNotILabelSorted # <<<<<<<<<<<<<< + * O_LABEL_SORTED = fst.kOLabelSorted + * NOT_O_LABEL_SORTED = fst.kNotOLabelSorted + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kNotILabelSorted); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2831, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_NOT_I_LABEL_SORTED, __pyx_t_1) < 0) __PYX_ERR(0, 2831, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2832 + * I_LABEL_SORTED = fst.kILabelSorted + * NOT_I_LABEL_SORTED = fst.kNotILabelSorted + * O_LABEL_SORTED = fst.kOLabelSorted # <<<<<<<<<<<<<< + * NOT_O_LABEL_SORTED = fst.kNotOLabelSorted + * WEIGHTED = fst.kWeighted + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kOLabelSorted); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2832, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_O_LABEL_SORTED, __pyx_t_1) < 0) __PYX_ERR(0, 2832, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2833 + * NOT_I_LABEL_SORTED = fst.kNotILabelSorted + * O_LABEL_SORTED = fst.kOLabelSorted + * NOT_O_LABEL_SORTED = fst.kNotOLabelSorted # <<<<<<<<<<<<<< + * WEIGHTED = fst.kWeighted + * UNWEIGHTED = fst.kUnweighted + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kNotOLabelSorted); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2833, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_NOT_O_LABEL_SORTED, __pyx_t_1) < 0) __PYX_ERR(0, 2833, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2834 + * O_LABEL_SORTED = fst.kOLabelSorted + * NOT_O_LABEL_SORTED = fst.kNotOLabelSorted + * WEIGHTED = fst.kWeighted # <<<<<<<<<<<<<< + * UNWEIGHTED = fst.kUnweighted + * CYCLIC = fst.kCyclic + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kWeighted); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2834, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_WEIGHTED, __pyx_t_1) < 0) __PYX_ERR(0, 2834, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2835 + * NOT_O_LABEL_SORTED = fst.kNotOLabelSorted + * WEIGHTED = fst.kWeighted + * UNWEIGHTED = fst.kUnweighted # <<<<<<<<<<<<<< + * CYCLIC = fst.kCyclic + * ACYCLIC = fst.kAcyclic + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kUnweighted); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2835, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_UNWEIGHTED, __pyx_t_1) < 0) __PYX_ERR(0, 2835, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2836 + * WEIGHTED = fst.kWeighted + * UNWEIGHTED = fst.kUnweighted + * CYCLIC = fst.kCyclic # <<<<<<<<<<<<<< + * ACYCLIC = fst.kAcyclic + * INITIAL_CYCLIC = fst.kInitialCyclic + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kCyclic); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2836, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_CYCLIC, __pyx_t_1) < 0) __PYX_ERR(0, 2836, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2837 + * UNWEIGHTED = fst.kUnweighted + * CYCLIC = fst.kCyclic + * ACYCLIC = fst.kAcyclic # <<<<<<<<<<<<<< + * INITIAL_CYCLIC = fst.kInitialCyclic + * INITIAL_ACYCLIC = fst.kInitialAcyclic + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kAcyclic); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2837, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ACYCLIC, __pyx_t_1) < 0) __PYX_ERR(0, 2837, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2838 + * CYCLIC = fst.kCyclic + * ACYCLIC = fst.kAcyclic + * INITIAL_CYCLIC = fst.kInitialCyclic # <<<<<<<<<<<<<< + * INITIAL_ACYCLIC = fst.kInitialAcyclic + * TOP_SORTED = fst.kTopSorted + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kInitialCyclic); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2838, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_INITIAL_CYCLIC, __pyx_t_1) < 0) __PYX_ERR(0, 2838, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2839 + * ACYCLIC = fst.kAcyclic + * INITIAL_CYCLIC = fst.kInitialCyclic + * INITIAL_ACYCLIC = fst.kInitialAcyclic # <<<<<<<<<<<<<< + * TOP_SORTED = fst.kTopSorted + * NOT_TOP_SORTED = fst.kNotTopSorted + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kInitialAcyclic); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2839, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_INITIAL_ACYCLIC, __pyx_t_1) < 0) __PYX_ERR(0, 2839, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2840 + * INITIAL_CYCLIC = fst.kInitialCyclic + * INITIAL_ACYCLIC = fst.kInitialAcyclic + * TOP_SORTED = fst.kTopSorted # <<<<<<<<<<<<<< + * NOT_TOP_SORTED = fst.kNotTopSorted + * ACCESSIBLE = fst.kAccessible + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kTopSorted); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2840, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TOP_SORTED, __pyx_t_1) < 0) __PYX_ERR(0, 2840, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2841 + * INITIAL_ACYCLIC = fst.kInitialAcyclic + * TOP_SORTED = fst.kTopSorted + * NOT_TOP_SORTED = fst.kNotTopSorted # <<<<<<<<<<<<<< + * ACCESSIBLE = fst.kAccessible + * NOT_ACCESSIBLE = fst.kNotAccessible + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kNotTopSorted); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2841, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_NOT_TOP_SORTED, __pyx_t_1) < 0) __PYX_ERR(0, 2841, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2842 + * TOP_SORTED = fst.kTopSorted + * NOT_TOP_SORTED = fst.kNotTopSorted + * ACCESSIBLE = fst.kAccessible # <<<<<<<<<<<<<< + * NOT_ACCESSIBLE = fst.kNotAccessible + * COACCESSIBLE = fst.kCoAccessible + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kAccessible); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2842, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ACCESSIBLE, __pyx_t_1) < 0) __PYX_ERR(0, 2842, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2843 + * NOT_TOP_SORTED = fst.kNotTopSorted + * ACCESSIBLE = fst.kAccessible + * NOT_ACCESSIBLE = fst.kNotAccessible # <<<<<<<<<<<<<< + * COACCESSIBLE = fst.kCoAccessible + * NOT_COACCESSIBLE = fst.kNotCoAccessible + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kNotAccessible); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2843, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_NOT_ACCESSIBLE, __pyx_t_1) < 0) __PYX_ERR(0, 2843, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2844 + * ACCESSIBLE = fst.kAccessible + * NOT_ACCESSIBLE = fst.kNotAccessible + * COACCESSIBLE = fst.kCoAccessible # <<<<<<<<<<<<<< + * NOT_COACCESSIBLE = fst.kNotCoAccessible + * STRING = fst.kString + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kCoAccessible); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2844, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_COACCESSIBLE, __pyx_t_1) < 0) __PYX_ERR(0, 2844, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2845 + * NOT_ACCESSIBLE = fst.kNotAccessible + * COACCESSIBLE = fst.kCoAccessible + * NOT_COACCESSIBLE = fst.kNotCoAccessible # <<<<<<<<<<<<<< + * STRING = fst.kString + * NOT_STRING = fst.kNotString + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kNotCoAccessible); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2845, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_NOT_COACCESSIBLE, __pyx_t_1) < 0) __PYX_ERR(0, 2845, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2846 + * COACCESSIBLE = fst.kCoAccessible + * NOT_COACCESSIBLE = fst.kNotCoAccessible + * STRING = fst.kString # <<<<<<<<<<<<<< + * NOT_STRING = fst.kNotString + * WEIGHTED_CYCLES = fst.kWeightedCycles + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kString); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2846, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_STRING, __pyx_t_1) < 0) __PYX_ERR(0, 2846, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2847 + * NOT_COACCESSIBLE = fst.kNotCoAccessible + * STRING = fst.kString + * NOT_STRING = fst.kNotString # <<<<<<<<<<<<<< + * WEIGHTED_CYCLES = fst.kWeightedCycles + * UNWEIGHTED_CYCLES = fst.kUnweightedCycles + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kNotString); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2847, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_NOT_STRING, __pyx_t_1) < 0) __PYX_ERR(0, 2847, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2848 + * STRING = fst.kString + * NOT_STRING = fst.kNotString + * WEIGHTED_CYCLES = fst.kWeightedCycles # <<<<<<<<<<<<<< + * UNWEIGHTED_CYCLES = fst.kUnweightedCycles + * NULL_PROPERTIES = fst.kNullProperties + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kWeightedCycles); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2848, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_WEIGHTED_CYCLES, __pyx_t_1) < 0) __PYX_ERR(0, 2848, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2849 + * NOT_STRING = fst.kNotString + * WEIGHTED_CYCLES = fst.kWeightedCycles + * UNWEIGHTED_CYCLES = fst.kUnweightedCycles # <<<<<<<<<<<<<< + * NULL_PROPERTIES = fst.kNullProperties + * COPY_PROPERTIES = fst.kCopyProperties + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kUnweightedCycles); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2849, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_UNWEIGHTED_CYCLES, __pyx_t_1) < 0) __PYX_ERR(0, 2849, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2850 + * WEIGHTED_CYCLES = fst.kWeightedCycles + * UNWEIGHTED_CYCLES = fst.kUnweightedCycles + * NULL_PROPERTIES = fst.kNullProperties # <<<<<<<<<<<<<< + * COPY_PROPERTIES = fst.kCopyProperties + * INTRINSIC_PROPERTIES = fst.kIntrinsicProperties + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kNullProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2850, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_NULL_PROPERTIES, __pyx_t_1) < 0) __PYX_ERR(0, 2850, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2851 + * UNWEIGHTED_CYCLES = fst.kUnweightedCycles + * NULL_PROPERTIES = fst.kNullProperties + * COPY_PROPERTIES = fst.kCopyProperties # <<<<<<<<<<<<<< + * INTRINSIC_PROPERTIES = fst.kIntrinsicProperties + * EXTRINSIC_PROPERTIES = fst.kExtrinsicProperties + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kCopyProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2851, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_COPY_PROPERTIES, __pyx_t_1) < 0) __PYX_ERR(0, 2851, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2852 + * NULL_PROPERTIES = fst.kNullProperties + * COPY_PROPERTIES = fst.kCopyProperties + * INTRINSIC_PROPERTIES = fst.kIntrinsicProperties # <<<<<<<<<<<<<< + * EXTRINSIC_PROPERTIES = fst.kExtrinsicProperties + * SET_START_PROPERTIES = fst.kSetStartProperties + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kIntrinsicProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2852, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_INTRINSIC_PROPERTIES, __pyx_t_1) < 0) __PYX_ERR(0, 2852, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2853 + * COPY_PROPERTIES = fst.kCopyProperties + * INTRINSIC_PROPERTIES = fst.kIntrinsicProperties + * EXTRINSIC_PROPERTIES = fst.kExtrinsicProperties # <<<<<<<<<<<<<< + * SET_START_PROPERTIES = fst.kSetStartProperties + * SET_FINAL_PROPERTIES = fst.kSetFinalProperties + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kExtrinsicProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2853, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_EXTRINSIC_PROPERTIES, __pyx_t_1) < 0) __PYX_ERR(0, 2853, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2854 + * INTRINSIC_PROPERTIES = fst.kIntrinsicProperties + * EXTRINSIC_PROPERTIES = fst.kExtrinsicProperties + * SET_START_PROPERTIES = fst.kSetStartProperties # <<<<<<<<<<<<<< + * SET_FINAL_PROPERTIES = fst.kSetFinalProperties + * ADD_STATE_PROPERTIES = fst.kAddStateProperties + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kSetStartProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2854, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SET_START_PROPERTIES, __pyx_t_1) < 0) __PYX_ERR(0, 2854, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2855 + * EXTRINSIC_PROPERTIES = fst.kExtrinsicProperties + * SET_START_PROPERTIES = fst.kSetStartProperties + * SET_FINAL_PROPERTIES = fst.kSetFinalProperties # <<<<<<<<<<<<<< + * ADD_STATE_PROPERTIES = fst.kAddStateProperties + * ADD_ARC_PROPERTIES = fst.kAddArcProperties + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kSetFinalProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2855, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SET_FINAL_PROPERTIES, __pyx_t_1) < 0) __PYX_ERR(0, 2855, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2856 + * SET_START_PROPERTIES = fst.kSetStartProperties + * SET_FINAL_PROPERTIES = fst.kSetFinalProperties + * ADD_STATE_PROPERTIES = fst.kAddStateProperties # <<<<<<<<<<<<<< + * ADD_ARC_PROPERTIES = fst.kAddArcProperties + * SET_ARC_PROPERTIES = fst.kSetArcProperties + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kAddStateProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2856, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ADD_STATE_PROPERTIES, __pyx_t_1) < 0) __PYX_ERR(0, 2856, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2857 + * SET_FINAL_PROPERTIES = fst.kSetFinalProperties + * ADD_STATE_PROPERTIES = fst.kAddStateProperties + * ADD_ARC_PROPERTIES = fst.kAddArcProperties # <<<<<<<<<<<<<< + * SET_ARC_PROPERTIES = fst.kSetArcProperties + * DELETE_STATE_PROPERTIES = fst.kDeleteStatesProperties + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kAddArcProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2857, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ADD_ARC_PROPERTIES, __pyx_t_1) < 0) __PYX_ERR(0, 2857, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2858 + * ADD_STATE_PROPERTIES = fst.kAddStateProperties + * ADD_ARC_PROPERTIES = fst.kAddArcProperties + * SET_ARC_PROPERTIES = fst.kSetArcProperties # <<<<<<<<<<<<<< + * DELETE_STATE_PROPERTIES = fst.kDeleteStatesProperties + * DELETE_ARC_PROPERTIES = fst.kDeleteArcsProperties + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kSetArcProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2858, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SET_ARC_PROPERTIES, __pyx_t_1) < 0) __PYX_ERR(0, 2858, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2859 + * ADD_ARC_PROPERTIES = fst.kAddArcProperties + * SET_ARC_PROPERTIES = fst.kSetArcProperties + * DELETE_STATE_PROPERTIES = fst.kDeleteStatesProperties # <<<<<<<<<<<<<< + * DELETE_ARC_PROPERTIES = fst.kDeleteArcsProperties + * STATE_SORT_PROPERTIES = fst.kStateSortProperties + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kDeleteStatesProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2859, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_DELETE_STATE_PROPERTIES, __pyx_t_1) < 0) __PYX_ERR(0, 2859, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2860 + * SET_ARC_PROPERTIES = fst.kSetArcProperties + * DELETE_STATE_PROPERTIES = fst.kDeleteStatesProperties + * DELETE_ARC_PROPERTIES = fst.kDeleteArcsProperties # <<<<<<<<<<<<<< + * STATE_SORT_PROPERTIES = fst.kStateSortProperties + * ARC_SORT_PROPERTIES = fst.kArcSortProperties + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kDeleteArcsProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2860, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_DELETE_ARC_PROPERTIES, __pyx_t_1) < 0) __PYX_ERR(0, 2860, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2861 + * DELETE_STATE_PROPERTIES = fst.kDeleteStatesProperties + * DELETE_ARC_PROPERTIES = fst.kDeleteArcsProperties + * STATE_SORT_PROPERTIES = fst.kStateSortProperties # <<<<<<<<<<<<<< + * ARC_SORT_PROPERTIES = fst.kArcSortProperties + * I_LABEL_INVARIANT_PROPERTIES = fst.kILabelInvariantProperties + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kStateSortProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2861, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_STATE_SORT_PROPERTIES, __pyx_t_1) < 0) __PYX_ERR(0, 2861, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2862 + * DELETE_ARC_PROPERTIES = fst.kDeleteArcsProperties + * STATE_SORT_PROPERTIES = fst.kStateSortProperties + * ARC_SORT_PROPERTIES = fst.kArcSortProperties # <<<<<<<<<<<<<< + * I_LABEL_INVARIANT_PROPERTIES = fst.kILabelInvariantProperties + * O_LABEL_INVARIANT_PROPERTIES = fst.kOLabelInvariantProperties + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kArcSortProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2862, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARC_SORT_PROPERTIES, __pyx_t_1) < 0) __PYX_ERR(0, 2862, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2863 + * STATE_SORT_PROPERTIES = fst.kStateSortProperties + * ARC_SORT_PROPERTIES = fst.kArcSortProperties + * I_LABEL_INVARIANT_PROPERTIES = fst.kILabelInvariantProperties # <<<<<<<<<<<<<< + * O_LABEL_INVARIANT_PROPERTIES = fst.kOLabelInvariantProperties + * WEIGHT_INVARIANT_PROPERTIES = fst.kWeightInvariantProperties + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kILabelInvariantProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2863, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_I_LABEL_INVARIANT_PROPERTIES, __pyx_t_1) < 0) __PYX_ERR(0, 2863, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2864 + * ARC_SORT_PROPERTIES = fst.kArcSortProperties + * I_LABEL_INVARIANT_PROPERTIES = fst.kILabelInvariantProperties + * O_LABEL_INVARIANT_PROPERTIES = fst.kOLabelInvariantProperties # <<<<<<<<<<<<<< + * WEIGHT_INVARIANT_PROPERTIES = fst.kWeightInvariantProperties + * ADD_SUPERFINAL_PROPERTIES = fst.kAddSuperFinalProperties + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kOLabelInvariantProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2864, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_O_LABEL_INVARIANT_PROPERTIES, __pyx_t_1) < 0) __PYX_ERR(0, 2864, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2865 + * I_LABEL_INVARIANT_PROPERTIES = fst.kILabelInvariantProperties + * O_LABEL_INVARIANT_PROPERTIES = fst.kOLabelInvariantProperties + * WEIGHT_INVARIANT_PROPERTIES = fst.kWeightInvariantProperties # <<<<<<<<<<<<<< + * ADD_SUPERFINAL_PROPERTIES = fst.kAddSuperFinalProperties + * RM_SUPERFINAL_PROPERTIES = fst.kRmSuperFinalProperties + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kWeightInvariantProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2865, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_WEIGHT_INVARIANT_PROPERTIES, __pyx_t_1) < 0) __PYX_ERR(0, 2865, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2866 + * O_LABEL_INVARIANT_PROPERTIES = fst.kOLabelInvariantProperties + * WEIGHT_INVARIANT_PROPERTIES = fst.kWeightInvariantProperties + * ADD_SUPERFINAL_PROPERTIES = fst.kAddSuperFinalProperties # <<<<<<<<<<<<<< + * RM_SUPERFINAL_PROPERTIES = fst.kRmSuperFinalProperties + * BINARY_PROPERTIES = fst.kBinaryProperties + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kAddSuperFinalProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2866, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ADD_SUPERFINAL_PROPERTIES, __pyx_t_1) < 0) __PYX_ERR(0, 2866, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2867 + * WEIGHT_INVARIANT_PROPERTIES = fst.kWeightInvariantProperties + * ADD_SUPERFINAL_PROPERTIES = fst.kAddSuperFinalProperties + * RM_SUPERFINAL_PROPERTIES = fst.kRmSuperFinalProperties # <<<<<<<<<<<<<< + * BINARY_PROPERTIES = fst.kBinaryProperties + * TRINARY_PROPERTIES = fst.kTrinaryProperties + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kRmSuperFinalProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2867, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_RM_SUPERFINAL_PROPERTIES, __pyx_t_1) < 0) __PYX_ERR(0, 2867, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2868 + * ADD_SUPERFINAL_PROPERTIES = fst.kAddSuperFinalProperties + * RM_SUPERFINAL_PROPERTIES = fst.kRmSuperFinalProperties + * BINARY_PROPERTIES = fst.kBinaryProperties # <<<<<<<<<<<<<< + * TRINARY_PROPERTIES = fst.kTrinaryProperties + * POS_TRINARY_PROPERTIES = fst.kPosTrinaryProperties + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kBinaryProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2868, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_BINARY_PROPERTIES, __pyx_t_1) < 0) __PYX_ERR(0, 2868, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2869 + * RM_SUPERFINAL_PROPERTIES = fst.kRmSuperFinalProperties + * BINARY_PROPERTIES = fst.kBinaryProperties + * TRINARY_PROPERTIES = fst.kTrinaryProperties # <<<<<<<<<<<<<< + * POS_TRINARY_PROPERTIES = fst.kPosTrinaryProperties + * NEG_TRINARY_PROPERTIES = fst.kNegTrinaryProperties + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kTrinaryProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2869, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TRINARY_PROPERTIES, __pyx_t_1) < 0) __PYX_ERR(0, 2869, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2870 + * BINARY_PROPERTIES = fst.kBinaryProperties + * TRINARY_PROPERTIES = fst.kTrinaryProperties + * POS_TRINARY_PROPERTIES = fst.kPosTrinaryProperties # <<<<<<<<<<<<<< + * NEG_TRINARY_PROPERTIES = fst.kNegTrinaryProperties + * FST_PROPERTIES = fst.kFstProperties + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kPosTrinaryProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2870, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_POS_TRINARY_PROPERTIES, __pyx_t_1) < 0) __PYX_ERR(0, 2870, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2871 + * TRINARY_PROPERTIES = fst.kTrinaryProperties + * POS_TRINARY_PROPERTIES = fst.kPosTrinaryProperties + * NEG_TRINARY_PROPERTIES = fst.kNegTrinaryProperties # <<<<<<<<<<<<<< + * FST_PROPERTIES = fst.kFstProperties + * + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kNegTrinaryProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2871, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_NEG_TRINARY_PROPERTIES, __pyx_t_1) < 0) __PYX_ERR(0, 2871, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2872 + * POS_TRINARY_PROPERTIES = fst.kPosTrinaryProperties + * NEG_TRINARY_PROPERTIES = fst.kNegTrinaryProperties + * FST_PROPERTIES = fst.kFstProperties # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_PyInt_From_uint64_t(fst::kFstProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2872, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_FST_PROPERTIES, __pyx_t_1) < 0) __PYX_ERR(0, 2872, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2878 + * + * + * ARC_I_LABEL_VALUE = fst.kArcILabelValue # <<<<<<<<<<<<<< + * ARC_O_LABEL_VALUE = fst.kArcOLabelValue + * ARC_WEIGHT_VALUE = fst.kArcWeightValue + */ + __pyx_t_1 = __Pyx_PyInt_From_uint32_t(fst::kArcILabelValue); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2878, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARC_I_LABEL_VALUE, __pyx_t_1) < 0) __PYX_ERR(0, 2878, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2879 + * + * ARC_I_LABEL_VALUE = fst.kArcILabelValue + * ARC_O_LABEL_VALUE = fst.kArcOLabelValue # <<<<<<<<<<<<<< + * ARC_WEIGHT_VALUE = fst.kArcWeightValue + * ARC_NEXT_STATE_VALUE = fst.kArcNextStateValue + */ + __pyx_t_1 = __Pyx_PyInt_From_uint32_t(fst::kArcOLabelValue); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2879, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARC_O_LABEL_VALUE, __pyx_t_1) < 0) __PYX_ERR(0, 2879, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2880 + * ARC_I_LABEL_VALUE = fst.kArcILabelValue + * ARC_O_LABEL_VALUE = fst.kArcOLabelValue + * ARC_WEIGHT_VALUE = fst.kArcWeightValue # <<<<<<<<<<<<<< + * ARC_NEXT_STATE_VALUE = fst.kArcNextStateValue + * ARC_NO_CACHE = fst.kArcNoCache + */ + __pyx_t_1 = __Pyx_PyInt_From_uint32_t(fst::kArcWeightValue); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2880, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARC_WEIGHT_VALUE, __pyx_t_1) < 0) __PYX_ERR(0, 2880, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2881 + * ARC_O_LABEL_VALUE = fst.kArcOLabelValue + * ARC_WEIGHT_VALUE = fst.kArcWeightValue + * ARC_NEXT_STATE_VALUE = fst.kArcNextStateValue # <<<<<<<<<<<<<< + * ARC_NO_CACHE = fst.kArcNoCache + * ARC_VALUE_FLAGS = fst.kArcValueFlags + */ + __pyx_t_1 = __Pyx_PyInt_From_uint32_t(fst::kArcNextStateValue); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2881, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARC_NEXT_STATE_VALUE, __pyx_t_1) < 0) __PYX_ERR(0, 2881, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2882 + * ARC_WEIGHT_VALUE = fst.kArcWeightValue + * ARC_NEXT_STATE_VALUE = fst.kArcNextStateValue + * ARC_NO_CACHE = fst.kArcNoCache # <<<<<<<<<<<<<< + * ARC_VALUE_FLAGS = fst.kArcValueFlags + * ARC_FLAGS = fst.kArcFlags + */ + __pyx_t_1 = __Pyx_PyInt_From_uint32_t(fst::kArcNoCache); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2882, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARC_NO_CACHE, __pyx_t_1) < 0) __PYX_ERR(0, 2882, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2883 + * ARC_NEXT_STATE_VALUE = fst.kArcNextStateValue + * ARC_NO_CACHE = fst.kArcNoCache + * ARC_VALUE_FLAGS = fst.kArcValueFlags # <<<<<<<<<<<<<< + * ARC_FLAGS = fst.kArcFlags + * + */ + __pyx_t_1 = __Pyx_PyInt_From_uint32_t(fst::kArcValueFlags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2883, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARC_VALUE_FLAGS, __pyx_t_1) < 0) __PYX_ERR(0, 2883, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2884 + * ARC_NO_CACHE = fst.kArcNoCache + * ARC_VALUE_FLAGS = fst.kArcValueFlags + * ARC_FLAGS = fst.kArcFlags # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_PyInt_From_uint32_t(fst::kArcFlags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2884, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARC_FLAGS, __pyx_t_1) < 0) __PYX_ERR(0, 2884, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2890 + * + * + * ENCODE_LABELS = fst.kEncodeLabels # <<<<<<<<<<<<<< + * ENCODE_WEIGHTS = fst.kEncodeWeights + * ENCODE_FLAGS = fst.kEncodeFlags + */ + __pyx_t_1 = __Pyx_PyInt_From_uint32_t(fst::kEncodeLabels); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2890, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ENCODE_LABELS, __pyx_t_1) < 0) __PYX_ERR(0, 2890, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2891 + * + * ENCODE_LABELS = fst.kEncodeLabels + * ENCODE_WEIGHTS = fst.kEncodeWeights # <<<<<<<<<<<<<< + * ENCODE_FLAGS = fst.kEncodeFlags + * + */ + __pyx_t_1 = __Pyx_PyInt_From_uint32_t(fst::kEncodeWeights); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2891, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ENCODE_WEIGHTS, __pyx_t_1) < 0) __PYX_ERR(0, 2891, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":2892 + * ENCODE_LABELS = fst.kEncodeLabels + * ENCODE_WEIGHTS = fst.kEncodeWeights + * ENCODE_FLAGS = fst.kEncodeFlags # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_PyInt_From_uint32_t(fst::kEncodeFlags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2892, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ENCODE_FLAGS, __pyx_t_1) < 0) __PYX_ERR(0, 2892, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":3258 + * + * cdef _Fst _map(_Fst ifst, + * float delta=fst.kDelta, # <<<<<<<<<<<<<< + * map_type=b"identity", + * double power=1., + */ + __pyx_k__67 = fst::kDelta; + + /* "pywrapfst.pyx":3272 + * + * cpdef _Fst arcmap(_Fst ifst, + * float delta=fst.kDelta, # <<<<<<<<<<<<<< + * map_type=b"identity", + * double power=1., + */ + __pyx_k__68 = fst::kDelta; + + /* "pywrapfst.pyx":3271 + * + * + * cpdef _Fst arcmap(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * map_type=b"identity", + */ + __pyx_k__68 = fst::kDelta; + + /* "pywrapfst.pyx":3384 + * + * cpdef _MutableFst determinize(_Fst ifst, + * float delta=fst.kShortestDelta, # <<<<<<<<<<<<<< + * det_type=b"functional", + * int64 nstate=fst.kNoStateId, + */ + __pyx_k__69 = fst::kShortestDelta; + + /* "pywrapfst.pyx":3386 + * float delta=fst.kShortestDelta, + * det_type=b"functional", + * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< + * int64 subsequential_label=0, + * weight=None, + */ + __pyx_k__70 = fst::kNoStateId; + + /* "pywrapfst.pyx":3384 + * + * cpdef _MutableFst determinize(_Fst ifst, + * float delta=fst.kShortestDelta, # <<<<<<<<<<<<<< + * det_type=b"functional", + * int64 nstate=fst.kNoStateId, + */ + __pyx_k__69 = fst::kShortestDelta; + + /* "pywrapfst.pyx":3386 + * float delta=fst.kShortestDelta, + * det_type=b"functional", + * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< + * int64 subsequential_label=0, + * weight=None, + */ + __pyx_k__70 = fst::kNoStateId; + + /* "pywrapfst.pyx":3477 + * + * cpdef _MutableFst disambiguate(_Fst ifst, + * float delta=fst.kDelta, # <<<<<<<<<<<<<< + * int64 nstate=fst.kNoStateId, + * int64 subsequential_label=0, + */ + __pyx_k__71 = fst::kDelta; + + /* "pywrapfst.pyx":3478 + * cpdef _MutableFst disambiguate(_Fst ifst, + * float delta=fst.kDelta, + * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< + * int64 subsequential_label=0, + * weight=None): + */ + __pyx_k__72 = fst::kNoStateId; + + /* "pywrapfst.pyx":3477 + * + * cpdef _MutableFst disambiguate(_Fst ifst, + * float delta=fst.kDelta, # <<<<<<<<<<<<<< + * int64 nstate=fst.kNoStateId, + * int64 subsequential_label=0, + */ + __pyx_k__71 = fst::kDelta; + + /* "pywrapfst.pyx":3478 + * cpdef _MutableFst disambiguate(_Fst ifst, + * float delta=fst.kDelta, + * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< + * int64 subsequential_label=0, + * weight=None): + */ + __pyx_k__72 = fst::kNoStateId; + + /* "pywrapfst.pyx":3548 + * + * + * cpdef bool equal(_Fst ifst1, _Fst ifst2, float delta=fst.kDelta): # <<<<<<<<<<<<<< + * """ + * equal(ifst1, ifst2, delta=0.0009765625) + */ + __pyx_k__73 = fst::kDelta; + __pyx_k__73 = fst::kDelta; + + /* "pywrapfst.pyx":3571 + * + * + * cpdef bool equivalent(_Fst ifst1, _Fst ifst2, float delta=fst.kDelta) except *: # <<<<<<<<<<<<<< + * """ + * equivalent(ifst1, ifst2, delta=0.0009765625) + */ + __pyx_k__74 = fst::kDelta; + __pyx_k__74 = fst::kDelta; + + /* "pywrapfst.pyx":3627 + * + * + * cpdef bool isomorphic(_Fst ifst1, _Fst ifst2, float delta=fst.kDelta): # <<<<<<<<<<<<<< + * """ + * isomorphic(ifst1, ifst2, delta=0.0009765625) + */ + __pyx_k__75 = fst::kDelta; + __pyx_k__75 = fst::kDelta; + + /* "pywrapfst.pyx":3654 + * + * cpdef _MutableFst prune(_Fst ifst, + * float delta=fst.kDelta, # <<<<<<<<<<<<<< + * int64 nstate=fst.kNoStateId, + * weight=None): + */ + __pyx_k__76 = fst::kDelta; + + /* "pywrapfst.pyx":3655 + * cpdef _MutableFst prune(_Fst ifst, + * float delta=fst.kDelta, + * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< + * weight=None): + * """ + */ + __pyx_k__77 = fst::kNoStateId; + + /* "pywrapfst.pyx":3654 + * + * cpdef _MutableFst prune(_Fst ifst, + * float delta=fst.kDelta, # <<<<<<<<<<<<<< + * int64 nstate=fst.kNoStateId, + * weight=None): + */ + __pyx_k__76 = fst::kDelta; + + /* "pywrapfst.pyx":3655 + * cpdef _MutableFst prune(_Fst ifst, + * float delta=fst.kDelta, + * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< + * weight=None): + * """ + */ + __pyx_k__77 = fst::kNoStateId; + + /* "pywrapfst.pyx":3687 + * + * cpdef _MutableFst push(_Fst ifst, + * float delta=fst.kDelta, # <<<<<<<<<<<<<< + * bool push_weights=False, + * bool push_labels=False, + */ + __pyx_k__78 = fst::kDelta; + + /* "pywrapfst.pyx":3686 + * + * + * cpdef _MutableFst push(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kDelta, + * bool push_weights=False, + */ + __pyx_k__78 = fst::kDelta; + + /* "pywrapfst.pyx":3743 + * _Fst ifst2, + * int32 npath=1, + * float delta=fst.kDelta, # <<<<<<<<<<<<<< + * time_t seed=0, + * select=b"uniform", + */ + __pyx_k__79 = fst::kDelta; + + /* "pywrapfst.pyx":3746 + * time_t seed=0, + * select=b"uniform", + * int32 max_length=INT32_MAX) except *: # <<<<<<<<<<<<<< + * """ + * randequivalent(ifst1, ifst2, npath=1, delta=0.0009765625, seed=0, + */ + __pyx_k__80 = INT32_MAX; + + /* "pywrapfst.pyx":3743 + * _Fst ifst2, + * int32 npath=1, + * float delta=fst.kDelta, # <<<<<<<<<<<<<< + * time_t seed=0, + * select=b"uniform", + */ + __pyx_k__79 = fst::kDelta; + + /* "pywrapfst.pyx":3746 + * time_t seed=0, + * select=b"uniform", + * int32 max_length=INT32_MAX) except *: # <<<<<<<<<<<<<< + * """ + * randequivalent(ifst1, ifst2, npath=1, delta=0.0009765625, seed=0, + */ + __pyx_k__80 = INT32_MAX; + + /* "pywrapfst.pyx":3790 + * time_t seed=0, + * select=b"uniform", + * int32 max_length=INT32_MAX, # <<<<<<<<<<<<<< + * bool weighted=False, + * bool remove_total_weight=False): + */ + __pyx_k__81 = INT32_MAX; + + /* "pywrapfst.pyx":3786 + * + * + * cpdef _MutableFst randgen(_Fst ifst, # <<<<<<<<<<<<<< + * int32 npath=1, + * time_t seed=0, + */ + __pyx_k__81 = INT32_MAX; + + /* "pywrapfst.pyx":3928 + * + * cdef vector[fst.WeightClass] *_shortestdistance(_Fst ifst, + * float delta=fst.kShortestDelta, # <<<<<<<<<<<<<< + * int64 nstate=fst.kNoStateId, + * queue_type=b"auto", + */ + __pyx_k__82 = fst::kShortestDelta; + + /* "pywrapfst.pyx":3929 + * cdef vector[fst.WeightClass] *_shortestdistance(_Fst ifst, + * float delta=fst.kShortestDelta, + * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< + * queue_type=b"auto", + * bool reverse=False) except *: + */ + __pyx_k__83 = fst::kNoStateId; + + /* "pywrapfst.pyx":3950 + * + * def shortestdistance(_Fst ifst, + * float delta=fst.kShortestDelta, # <<<<<<<<<<<<<< + * int64 nstate=fst.kNoStateId, + * queue_type=b"auto", + */ + __pyx_k__84 = fst::kShortestDelta; + + /* "pywrapfst.pyx":3951 + * def shortestdistance(_Fst ifst, + * float delta=fst.kShortestDelta, + * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< + * queue_type=b"auto", + * bool reverse=False): + */ + __pyx_k__85 = fst::kNoStateId; + + /* "pywrapfst.pyx":3949 + * + * + * def shortestdistance(_Fst ifst, # <<<<<<<<<<<<<< + * float delta=fst.kShortestDelta, + * int64 nstate=fst.kNoStateId, + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_9pywrapfst_51shortestdistance, NULL, __pyx_n_s_pywrapfst_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3949, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_shortestdistance, __pyx_t_1) < 0) __PYX_ERR(0, 3949, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":3987 + * + * cpdef _MutableFst shortestpath(_Fst ifst, + * float delta=fst.kShortestDelta, # <<<<<<<<<<<<<< + * int32 nshortest=1, + * int64 nstate=fst.kNoStateId, + */ + __pyx_k__86 = fst::kShortestDelta; + + /* "pywrapfst.pyx":3989 + * float delta=fst.kShortestDelta, + * int32 nshortest=1, + * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< + * queue_type=b"auto", + * bool unique=False, + */ + __pyx_k__87 = fst::kNoStateId; + + /* "pywrapfst.pyx":3987 + * + * cpdef _MutableFst shortestpath(_Fst ifst, + * float delta=fst.kShortestDelta, # <<<<<<<<<<<<<< + * int32 nshortest=1, + * int64 nstate=fst.kNoStateId, + */ + __pyx_k__86 = fst::kShortestDelta; + + /* "pywrapfst.pyx":3989 + * float delta=fst.kShortestDelta, + * int32 nshortest=1, + * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< + * queue_type=b"auto", + * bool unique=False, + */ + __pyx_k__87 = fst::kNoStateId; + + /* "pywrapfst.pyx":4140 + * + * def __cinit__(self, + * string fst_type=b"vector", # <<<<<<<<<<<<<< + * string arc_type=b"standard", + * SymbolTable isymbols=None, + */ + __pyx_t_6 = __pyx_convert_string_from_py_std__in_string(__pyx_n_b_vector); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4140, __pyx_L1_error) + __pyx_k__88 = __pyx_t_6; + + /* "pywrapfst.pyx":4141 + * def __cinit__(self, + * string fst_type=b"vector", + * string arc_type=b"standard", # <<<<<<<<<<<<<< + * SymbolTable isymbols=None, + * SymbolTable osymbols=None, + */ + __pyx_t_6 = __pyx_convert_string_from_py_std__in_string(__pyx_n_b_standard); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4141, __pyx_L1_error) + __pyx_k__89 = __pyx_t_6; + + /* "pywrapfst.pyx":4239 + * + * @classmethod + * def open(cls, *filenames): # <<<<<<<<<<<<<< + * """ + * FarReader.open(*filenames) + */ + __pyx_t_1 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_9pywrapfst_FarReader, __pyx_n_s_open); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "pywrapfst.pyx":4238 + * return "<{} FarReader at 0x{:x}>".format(self.far_type(), id(self)) + * + * @classmethod # <<<<<<<<<<<<<< + * def open(cls, *filenames): + * """ + */ + __pyx_t_2 = __Pyx_Method_ClassMethod(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (PyDict_SetItem((PyObject *)__pyx_ptype_9pywrapfst_FarReader->tp_dict, __pyx_n_s_open, __pyx_t_2) < 0) __PYX_ERR(0, 4239, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_9pywrapfst_FarReader); + + /* "pywrapfst.pyx":4388 + * + * @classmethod + * def create(cls, filename, arc_type=b"standard", far_type=b"default"): # <<<<<<<<<<<<<< + * """ + * FarWriter. + */ + __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_9pywrapfst_FarWriter, __pyx_n_s_create); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "pywrapfst.pyx":4387 + * return "<{} FarWriter at 0x{:x}>".format(self.far_type(), id(self)) + * + * @classmethod # <<<<<<<<<<<<<< + * def create(cls, filename, arc_type=b"standard", far_type=b"default"): + * """ + */ + __pyx_t_1 = __Pyx_Method_ClassMethod(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem((PyObject *)__pyx_ptype_9pywrapfst_FarWriter->tp_dict, __pyx_n_s_create, __pyx_t_1) < 0) __PYX_ERR(0, 4388, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_ptype_9pywrapfst_FarWriter); + + /* "pywrapfst.pyx":4487 + * + * + * _fst_error_fatal_old = fst.FLAGS_fst_error_fatal # <<<<<<<<<<<<<< + * fst.FLAGS_fst_error_fatal = False + * + */ + __pyx_t_1 = __Pyx_PyBool_FromLong(FLAGS_fst_error_fatal); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4487, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_fst_error_fatal_old, __pyx_t_1) < 0) __PYX_ERR(0, 4487, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":4488 + * + * _fst_error_fatal_old = fst.FLAGS_fst_error_fatal + * fst.FLAGS_fst_error_fatal = False # <<<<<<<<<<<<<< + * + * + */ + FLAGS_fst_error_fatal = 0; + + /* "pywrapfst.pyx":4491 + * + * + * @atexit.register # <<<<<<<<<<<<<< + * def _reset_fst_error_fatal(): + * fst.FLAGS_fst_error_fatal = _fst_error_fatal_old + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_atexit); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_register); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "pywrapfst.pyx":4492 + * + * @atexit.register + * def _reset_fst_error_fatal(): # <<<<<<<<<<<<<< + * fst.FLAGS_fst_error_fatal = _fst_error_fatal_old + * + */ + __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_9pywrapfst_59_reset_fst_error_fatal, NULL, __pyx_n_s_pywrapfst_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4492, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4491, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4491, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4491, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reset_fst_error_fatal, __pyx_t_1) < 0) __PYX_ERR(0, 4492, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pywrapfst.pyx":1 + * #cython: nonecheck=True # <<<<<<<<<<<<<< + * # Licensed under the Apache License, Version 2.0 (the "License"); + * # you may not use this file except in compliance with the License. + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test_2, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "vector.from_py":45 + * + * @cname("__pyx_convert_vector_from_py_std_3a__3a_string") + * cdef vector[X] __pyx_convert_vector_from_py_std_3a__3a_string(object o) except *: # <<<<<<<<<<<<<< + * cdef vector[X] v + * for item in o: + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init pywrapfst", 0, __pyx_lineno, __pyx_filename); + } + Py_DECREF(__pyx_m); __pyx_m = 0; + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init pywrapfst"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #elif PY_MAJOR_VERSION >= 3 + return __pyx_m; + #else + return; + #endif +} + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule((char *)modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* PyCFunctionFastCall */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { + PyCFunctionObject *func = (PyCFunctionObject*)func_obj; + PyCFunction meth = PyCFunction_GET_FUNCTION(func); + PyObject *self = PyCFunction_GET_SELF(func); + int flags = PyCFunction_GET_FLAGS(func); + assert(PyCFunction_Check(func)); + assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS))); + assert(nargs >= 0); + assert(nargs == 0 || args != NULL); + /* _PyCFunction_FastCallDict() must not be called with an exception set, + because it may clear it (directly or indirectly) and so the + caller loses its exception */ + assert(!PyErr_Occurred()); + if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { + return (*((__Pyx_PyCFunctionFastWithKeywords)meth)) (self, args, nargs, NULL); + } else { + return (*((__Pyx_PyCFunctionFast)meth)) (self, args, nargs); + } +} +#endif + +/* PyFunctionFastCall */ +#if CYTHON_FAST_PYCALL +#include "frameobject.h" +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = f->f_localsplus; + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; +#endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + return NULL; + } + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif +#endif + +/* PyObjectCall */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallMethO */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallOneArg */ +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); + } +#endif + if (likely(PyCFunction_Check(func))) { + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); +#endif + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* GetModuleGlobalName */ +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) { + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS + result = PyDict_GetItem(__pyx_d, name); + if (likely(result)) { + Py_INCREF(result); + } else { +#else + result = PyObject_GetItem(__pyx_d, name); + if (!result) { + PyErr_Clear(); +#endif + result = __Pyx_GetBuiltinName(name); + } + return result; +} + +/* PyErrFetchRestore */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + +/* RaiseException */ + #if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + __Pyx_PyThreadState_declare + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +/* RaiseArgTupleInvalid */ + static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* RaiseDoubleKeywords */ + static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ + static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +/* PyObjectCallNoArg */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, NULL, 0); + } +#endif +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || __Pyx_TypeCheck(func, __pyx_CyFunctionType))) { +#else + if (likely(PyCFunction_Check(func))) { +#endif + if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { + return __Pyx_PyObject_CallMethO(func, NULL); + } + } + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); +} +#endif + +/* ExtTypeTest */ + static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +/* ArgTypeTest */ + static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + else if (exact) { + #if PY_MAJOR_VERSION == 2 + if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); + return 0; +} + +/* WriteUnraisableException */ + static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, + CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, + int full_traceback, CYTHON_UNUSED int nogil) { + PyObject *old_exc, *old_val, *old_tb; + PyObject *ctx; + __Pyx_PyThreadState_declare +#ifdef WITH_THREAD + PyGILState_STATE state; + if (nogil) + state = PyGILState_Ensure(); +#ifdef _MSC_VER + else state = (PyGILState_STATE)-1; +#endif +#endif + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); + if (full_traceback) { + Py_XINCREF(old_exc); + Py_XINCREF(old_val); + Py_XINCREF(old_tb); + __Pyx_ErrRestore(old_exc, old_val, old_tb); + PyErr_PrintEx(1); + } + #if PY_MAJOR_VERSION < 3 + ctx = PyString_FromString(name); + #else + ctx = PyUnicode_FromString(name); + #endif + __Pyx_ErrRestore(old_exc, old_val, old_tb); + if (!ctx) { + PyErr_WriteUnraisable(Py_None); + } else { + PyErr_WriteUnraisable(ctx); + Py_DECREF(ctx); + } +#ifdef WITH_THREAD + if (nogil) + PyGILState_Release(state); +#endif +} + +/* KeywordStringCheck */ + static int __Pyx_CheckKeywordStrings( + PyObject *kwdict, + const char* function_name, + int kw_allowed) +{ + PyObject* key = 0; + Py_ssize_t pos = 0; +#if CYTHON_COMPILING_IN_PYPY + if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0)) + goto invalid_keyword; + return 1; +#else + while (PyDict_Next(kwdict, &pos, &key, 0)) { + #if PY_MAJOR_VERSION < 3 + if (unlikely(!PyString_Check(key))) + #endif + if (unlikely(!PyUnicode_Check(key))) + goto invalid_keyword_type; + } + if ((!kw_allowed) && unlikely(key)) + goto invalid_keyword; + return 1; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + return 0; +#endif +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif + return 0; +} + +/* SaveResetException */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if PY_VERSION_HEX >= 0x030700A2 + *type = tstate->exc_state.exc_type; + *value = tstate->exc_state.exc_value; + *tb = tstate->exc_state.exc_traceback; + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + #endif + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if PY_VERSION_HEX >= 0x030700A2 + tmp_type = tstate->exc_state.exc_type; + tmp_value = tstate->exc_state.exc_value; + tmp_tb = tstate->exc_state.exc_traceback; + tstate->exc_state.exc_type = type; + tstate->exc_state.exc_value = value; + tstate->exc_state.exc_traceback = tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +#endif + +/* PyErrExceptionMatches */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; icurexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; + if (unlikely(PyTuple_Check(err))) + return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); +} +#endif + +/* GetException */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) { +#endif + PyObject *local_type, *local_value, *local_tb; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } + #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if PY_VERSION_HEX >= 0x030700A2 + tmp_type = tstate->exc_state.exc_type; + tmp_value = tstate->exc_state.exc_value; + tmp_tb = tstate->exc_state.exc_traceback; + tstate->exc_state.exc_type = local_type; + tstate->exc_state.exc_value = local_value; + tstate->exc_state.exc_traceback = local_tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +} + +/* RaiseTooManyValuesToUnpack */ + static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +/* RaiseNeedMoreValuesToUnpack */ + static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +/* IterFinish */ + static CYTHON_INLINE int __Pyx_IterFinish(void) { +#if CYTHON_FAST_THREAD_STATE + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* exc_type = tstate->curexc_type; + if (unlikely(exc_type)) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) { + PyObject *exc_value, *exc_tb; + exc_value = tstate->curexc_value; + exc_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; + Py_DECREF(exc_type); + Py_XDECREF(exc_value); + Py_XDECREF(exc_tb); + return 0; + } else { + return -1; + } + } + return 0; +#else + if (unlikely(PyErr_Occurred())) { + if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { + PyErr_Clear(); + return 0; + } else { + return -1; + } + } + return 0; +#endif +} + +/* UnpackItemEndCheck */ + static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { + if (unlikely(retval)) { + Py_DECREF(retval); + __Pyx_RaiseTooManyValuesError(expected); + return -1; + } else { + return __Pyx_IterFinish(); + } + return 0; +} + +/* IterNext */ + static PyObject *__Pyx_PyIter_Next2Default(PyObject* defval) { + PyObject* exc_type; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + exc_type = __Pyx_PyErr_Occurred(); + if (unlikely(exc_type)) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) + return NULL; + if (defval) { + __Pyx_PyErr_Clear(); + Py_INCREF(defval); + } + return defval; + } + if (defval) { + Py_INCREF(defval); + return defval; + } + __Pyx_PyErr_SetNone(PyExc_StopIteration); + return NULL; +} +static void __Pyx_PyIter_Next_ErrorNoIterator(PyObject *iterator) { + PyErr_Format(PyExc_TypeError, + "%.200s object is not an iterator", Py_TYPE(iterator)->tp_name); +} +static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject* iterator, PyObject* defval) { + PyObject* next; + iternextfunc iternext = Py_TYPE(iterator)->tp_iternext; + if (likely(iternext)) { +#if CYTHON_USE_TYPE_SLOTS + next = iternext(iterator); + if (likely(next)) + return next; + #if PY_VERSION_HEX >= 0x02070000 + if (unlikely(iternext == &_PyObject_NextNotImplemented)) + return NULL; + #endif +#else + next = PyIter_Next(iterator); + if (likely(next)) + return next; +#endif + } else if (CYTHON_USE_TYPE_SLOTS || !PyIter_Check(iterator)) { + __Pyx_PyIter_Next_ErrorNoIterator(iterator); + return NULL; + } + return __Pyx_PyIter_Next2Default(defval); +} + +/* SetVTable */ + static int __Pyx_SetVtable(PyObject *dict, void *vtable) { +#if PY_VERSION_HEX >= 0x02070000 + PyObject *ob = PyCapsule_New(vtable, 0, 0); +#else + PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); +#endif + if (!ob) + goto bad; + if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + +/* SetupReduce */ + static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { + int ret; + PyObject *name_attr; + name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name); + if (likely(name_attr)) { + ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); + } else { + ret = -1; + } + if (unlikely(ret < 0)) { + PyErr_Clear(); + ret = 0; + } + Py_XDECREF(name_attr); + return ret; +} +static int __Pyx_setup_reduce(PyObject* type_obj) { + int ret = 0; + PyObject *object_reduce = NULL; + PyObject *object_reduce_ex = NULL; + PyObject *reduce = NULL; + PyObject *reduce_ex = NULL; + PyObject *reduce_cython = NULL; + PyObject *setstate = NULL; + PyObject *setstate_cython = NULL; +#if CYTHON_USE_PYTYPE_LOOKUP + if (_PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate)) goto GOOD; +#else + if (PyObject_HasAttr(type_obj, __pyx_n_s_getstate)) goto GOOD; +#endif +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto BAD; +#else + object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto BAD; +#endif + reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto BAD; + if (reduce_ex == object_reduce_ex) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto BAD; +#else + object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto BAD; +#endif + reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto BAD; + if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { + reduce_cython = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_cython); if (unlikely(!reduce_cython)) goto BAD; + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto BAD; + setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); + if (!setstate) PyErr_Clear(); + if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { + setstate_cython = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate_cython); if (unlikely(!setstate_cython)) goto BAD; + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto BAD; + } + PyType_Modified((PyTypeObject*)type_obj); + } + } + goto GOOD; +BAD: + if (!PyErr_Occurred()) + PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); + ret = -1; +GOOD: +#if !CYTHON_USE_PYTYPE_LOOKUP + Py_XDECREF(object_reduce); + Py_XDECREF(object_reduce_ex); +#endif + Py_XDECREF(reduce); + Py_XDECREF(reduce_ex); + Py_XDECREF(reduce_cython); + Py_XDECREF(setstate); + Py_XDECREF(setstate_cython); + return ret; +} + +/* Import */ + static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_MAJOR_VERSION < 3 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.')) { + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_MAJOR_VERSION < 3 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +/* CalculateMetaclass */ + static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) { + Py_ssize_t i, nbases = PyTuple_GET_SIZE(bases); + for (i=0; i < nbases; i++) { + PyTypeObject *tmptype; + PyObject *tmp = PyTuple_GET_ITEM(bases, i); + tmptype = Py_TYPE(tmp); +#if PY_MAJOR_VERSION < 3 + if (tmptype == &PyClass_Type) + continue; +#endif + if (!metaclass) { + metaclass = tmptype; + continue; + } + if (PyType_IsSubtype(metaclass, tmptype)) + continue; + if (PyType_IsSubtype(tmptype, metaclass)) { + metaclass = tmptype; + continue; + } + PyErr_SetString(PyExc_TypeError, + "metaclass conflict: " + "the metaclass of a derived class " + "must be a (non-strict) subclass " + "of the metaclasses of all its bases"); + return NULL; + } + if (!metaclass) { +#if PY_MAJOR_VERSION < 3 + metaclass = &PyClass_Type; +#else + metaclass = &PyType_Type; +#endif + } + Py_INCREF((PyObject*) metaclass); + return (PyObject*) metaclass; +} + +/* Py3ClassCreate */ + static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, + PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) { + PyObject *ns; + if (metaclass) { + PyObject *prep = __Pyx_PyObject_GetAttrStr(metaclass, __pyx_n_s_prepare); + if (prep) { + PyObject *pargs = PyTuple_Pack(2, name, bases); + if (unlikely(!pargs)) { + Py_DECREF(prep); + return NULL; + } + ns = PyObject_Call(prep, pargs, mkw); + Py_DECREF(prep); + Py_DECREF(pargs); + } else { + if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError))) + return NULL; + PyErr_Clear(); + ns = PyDict_New(); + } + } else { + ns = PyDict_New(); + } + if (unlikely(!ns)) + return NULL; + if (unlikely(PyObject_SetItem(ns, __pyx_n_s_module, modname) < 0)) goto bad; + if (unlikely(PyObject_SetItem(ns, __pyx_n_s_qualname, qualname) < 0)) goto bad; + if (unlikely(doc && PyObject_SetItem(ns, __pyx_n_s_doc, doc) < 0)) goto bad; + return ns; +bad: + Py_DECREF(ns); + return NULL; +} +static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, + PyObject *dict, PyObject *mkw, + int calculate_metaclass, int allow_py2_metaclass) { + PyObject *result, *margs; + PyObject *owned_metaclass = NULL; + if (allow_py2_metaclass) { + owned_metaclass = PyObject_GetItem(dict, __pyx_n_s_metaclass); + if (owned_metaclass) { + metaclass = owned_metaclass; + } else if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) { + PyErr_Clear(); + } else { + return NULL; + } + } + if (calculate_metaclass && (!metaclass || PyType_Check(metaclass))) { + metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases); + Py_XDECREF(owned_metaclass); + if (unlikely(!metaclass)) + return NULL; + owned_metaclass = metaclass; + } + margs = PyTuple_Pack(3, name, bases, dict); + if (unlikely(!margs)) { + result = NULL; + } else { + result = PyObject_Call(metaclass, margs, mkw); + Py_DECREF(margs); + } + Py_XDECREF(owned_metaclass); + return result; +} + +/* GetNameInClass */ + static PyObject *__Pyx_GetGlobalNameAfterAttributeLookup(PyObject *name) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + return NULL; + __Pyx_PyErr_Clear(); + return __Pyx_GetModuleGlobalName(name); +} +static PyObject *__Pyx_GetNameInClass(PyObject *nmspace, PyObject *name) { + PyObject *result; + result = __Pyx_PyObject_GetAttrStr(nmspace, name); + if (!result) { + result = __Pyx_GetGlobalNameAfterAttributeLookup(name); + } + return result; +} + +/* ClassMethod */ + static PyObject* __Pyx_Method_ClassMethod(PyObject *method) { +#if CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM <= 0x05080000 + if (PyObject_TypeCheck(method, &PyWrapperDescr_Type)) { + return PyClassMethod_New(method); + } +#else +#if CYTHON_COMPILING_IN_PYSTON || CYTHON_COMPILING_IN_PYPY + if (PyMethodDescr_Check(method)) { +#else + static PyTypeObject *methoddescr_type = NULL; + if (methoddescr_type == NULL) { + PyObject *meth = PyObject_GetAttrString((PyObject*)&PyList_Type, "append"); + if (!meth) return NULL; + methoddescr_type = Py_TYPE(meth); + Py_DECREF(meth); + } + if (__Pyx_TypeCheck(method, methoddescr_type)) { +#endif + PyMethodDescrObject *descr = (PyMethodDescrObject *)method; + #if PY_VERSION_HEX < 0x03020000 + PyTypeObject *d_type = descr->d_type; + #else + PyTypeObject *d_type = descr->d_common.d_type; + #endif + return PyDescr_NewClassMethod(d_type, descr->d_method); + } +#endif + else if (PyMethod_Check(method)) { + return PyClassMethod_New(PyMethod_GET_FUNCTION(method)); + } + else if (PyCFunction_Check(method)) { + return PyClassMethod_New(method); + } +#ifdef __Pyx_CyFunction_USED + else if (__Pyx_TypeCheck(method, __pyx_CyFunctionType)) { + return PyClassMethod_New(method); + } +#endif + PyErr_SetString(PyExc_TypeError, + "Class-level classmethod() can only be called on " + "a method_descriptor or instance method."); + return NULL; +} + +/* FetchCommonType */ + static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* fake_module; + PyTypeObject* cached_type = NULL; + fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI); + if (!fake_module) return NULL; + Py_INCREF(fake_module); + cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name); + if (cached_type) { + if (!PyType_Check((PyObject*)cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", + type->tp_name); + goto bad; + } + if (cached_type->tp_basicsize != type->tp_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + type->tp_name); + goto bad; + } + } else { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; + } +done: + Py_DECREF(fake_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} + +/* CythonFunction */ + static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure) +{ + if (unlikely(op->func_doc == NULL)) { + if (op->func.m_ml->ml_doc) { +#if PY_MAJOR_VERSION >= 3 + op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc); +#else + op->func_doc = PyString_FromString(op->func.m_ml->ml_doc); +#endif + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } + } + Py_INCREF(op->func_doc); + return op->func_doc; +} +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp = op->func_doc; + if (value == NULL) { + value = Py_None; + } + Py_INCREF(value); + op->func_doc = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_name == NULL)) { +#if PY_MAJOR_VERSION >= 3 + op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name); +#else + op->func_name = PyString_InternFromString(op->func.m_ml->ml_name); +#endif + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + tmp = op->func_name; + Py_INCREF(value); + op->func_name = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op) +{ + Py_INCREF(op->func_qualname); + return op->func_qualname; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + tmp = op->func_qualname; + Py_INCREF(value); + op->func_qualname = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure) +{ + PyObject *self; + self = m->func_closure; + if (self == NULL) + self = Py_None; + Py_INCREF(self); + return self; +} +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; + if (unlikely(value == NULL)) { + PyErr_SetString(PyExc_TypeError, + "function's dictionary may not be deleted"); + return -1; + } + if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "setting function's dictionary to a non-dict"); + return -1; + } + tmp = op->func_dict; + Py_INCREF(value); + op->func_dict = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op) +{ + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op) +{ + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { + int result = 0; + PyObject *res = op->defaults_getter((PyObject *) op); + if (unlikely(!res)) + return -1; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + op->defaults_tuple = PyTuple_GET_ITEM(res, 0); + Py_INCREF(op->defaults_tuple); + op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); + Py_INCREF(op->defaults_kwdict); + #else + op->defaults_tuple = PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; + } + #endif + Py_DECREF(res); + return result; +} +static int +__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value) { + PyObject* tmp; + if (!value) { + value = Py_None; + } else if (value != Py_None && !PyTuple_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + Py_INCREF(value); + tmp = op->defaults_tuple; + op->defaults_tuple = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_tuple; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value) { + PyObject* tmp; + if (!value) { + value = Py_None; + } else if (value != Py_None && !PyDict_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + Py_INCREF(value); + tmp = op->defaults_kwdict; + op->defaults_kwdict = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_kwdict; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value) { + PyObject* tmp; + if (!value || value == Py_None) { + value = NULL; + } else if (!PyDict_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + tmp = op->func_annotations; + op->func_annotations = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op) { + PyObject* result = op->func_annotations; + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; +} +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {(char *) "__self__", (getter)__Pyx_CyFunction_get_self, 0, 0, 0}, + {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { + {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), PY_WRITE_RESTRICTED, 0}, + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromString(m->func.m_ml->ml_name); +#else + return PyString_FromString(m->func.m_ml->ml_name); +#endif +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if PY_VERSION_HEX < 0x030500A0 +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist) +#endif +static PyObject *__Pyx_CyFunction_New(PyTypeObject *type, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + __pyx_CyFunctionObject *op = PyObject_GC_New(__pyx_CyFunctionObject, type); + if (op == NULL) + return NULL; + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; + op->func.m_ml = ml; + op->func.m_self = (PyObject *) op; + Py_XINCREF(closure); + op->func_closure = closure; + Py_XINCREF(module); + op->func.m_module = module; + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; + op->func_classobj = NULL; + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults_pyobjects = 0; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + PyObject_GC_Track(op); + return (PyObject *) op; +} +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); + Py_CLEAR(m->func.m_module); + Py_CLEAR(m->func_dict); + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); + Py_CLEAR(m->func_classobj); + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_XDECREF(pydefaults[i]); + PyObject_Free(m->defaults); + m->defaults = NULL; + } + return 0; +} +static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + PyObject_GC_Del(m); +} +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + __Pyx__CyFunction_dealloc(m); +} +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + Py_VISIT(m->func_closure); + Py_VISIT(m->func.m_module); + Py_VISIT(m->func_dict); + Py_VISIT(m->func_name); + Py_VISIT(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + Py_VISIT(m->func_code); + Py_VISIT(m->func_classobj); + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_VISIT(pydefaults[i]); + } + return 0; +} +static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type) +{ + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) { + Py_INCREF(func); + return func; + } + if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) { + if (type == NULL) + type = (PyObject *)(Py_TYPE(obj)); + return __Pyx_PyMethod_New(func, type, (PyObject *)(Py_TYPE(type))); + } + if (obj == Py_None) + obj = NULL; + return __Pyx_PyMethod_New(func, obj, type); +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromFormat("", + op->func_qualname, (void *)op); +#else + return PyString_FromFormat("", + PyString_AsString(op->func_qualname), (void *)op); +#endif +} +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + Py_ssize_t size; + switch (f->m_ml->ml_flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { + size = PyTuple_GET_SIZE(arg); + if (likely(size == 0)) + return (*meth)(self, NULL); + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { + size = PyTuple_GET_SIZE(arg); + if (likely(size == 1)) { + PyObject *result, *arg0; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + arg0 = PyTuple_GET_ITEM(arg, 0); + #else + arg0 = PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; + #endif + result = (*meth)(self, arg0); + #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) + Py_DECREF(arg0); + #endif + return result; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags in " + "__Pyx_CyFunction_Call. METH_OLDARGS is no " + "longer supported!"); + return NULL; + } + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + f->m_ml->ml_name); + return NULL; +} +static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + return __Pyx_CyFunction_CallMethod(func, ((PyCFunctionObject*)func)->m_self, arg, kw); +} +static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + Py_ssize_t argc; + PyObject *new_args; + PyObject *self; + argc = PyTuple_GET_SIZE(args); + new_args = PyTuple_GetSlice(args, 1, argc); + if (unlikely(!new_args)) + return NULL; + self = PyTuple_GetItem(args, 0); + if (unlikely(!self)) { + Py_DECREF(new_args); + return NULL; + } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); + } + return result; +} +static PyTypeObject __pyx_CyFunctionType_type = { + PyVarObject_HEAD_INIT(0, 0) + "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + (destructor) __Pyx_CyFunction_dealloc, + 0, + 0, + 0, +#if PY_MAJOR_VERSION < 3 + 0, +#else + 0, +#endif + (reprfunc) __Pyx_CyFunction_repr, + 0, + 0, + 0, + 0, + __Pyx_CyFunction_CallAsMethod, + 0, + 0, + 0, + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, + 0, + (traverseproc) __Pyx_CyFunction_traverse, + (inquiry) __Pyx_CyFunction_clear, + 0, +#if PY_VERSION_HEX < 0x030500A0 + offsetof(__pyx_CyFunctionObject, func_weakreflist), +#else + offsetof(PyCFunctionObject, m_weakreflist), +#endif + 0, + 0, + __pyx_CyFunction_methods, + __pyx_CyFunction_members, + __pyx_CyFunction_getsets, + 0, + 0, + __Pyx_CyFunction_descr_get, + 0, + offsetof(__pyx_CyFunctionObject, func_dict), + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +}; +static int __pyx_CyFunction_init(void) { + __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); + if (unlikely(__pyx_CyFunctionType == NULL)) { + return -1; + } + return 0; +} +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_Malloc(size); + if (unlikely(!m->defaults)) + return PyErr_NoMemory(); + memset(m->defaults, 0, size); + m->defaults_pyobjects = pyobjects; + return m->defaults; +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_tuple = tuple; + Py_INCREF(tuple); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_kwdict = dict; + Py_INCREF(dict); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->func_annotations = dict; + Py_INCREF(dict); +} + +/* CLineInTraceback */ + #ifndef CYTHON_CLINE_IN_TRACEBACK +static int __Pyx_CLineForTraceback(CYTHON_UNUSED PyThreadState *tstate, int c_line) { + PyObject *use_cline; + PyObject *ptype, *pvalue, *ptraceback; +#if CYTHON_COMPILING_IN_CPYTHON + PyObject **cython_runtime_dict; +#endif + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); +#if CYTHON_COMPILING_IN_CPYTHON + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + use_cline = PyDict_GetItem(*cython_runtime_dict, __pyx_n_s_cline_in_traceback); + } else +#endif + { + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + if (use_cline_obj) { + use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_DECREF(use_cline_obj); + } else { + PyErr_Clear(); + use_cline = NULL; + } + } + if (!use_cline) { + c_line = 0; + PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + } + else if (PyObject_Not(use_cline) != 0) { + c_line = 0; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; +} +#endif + +/* CodeObjectCache */ + static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +/* AddTraceback */ + #include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + if (c_line) { + c_line = __Pyx_CLineForTraceback(tstate, c_line); + } + py_code = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); + } + py_frame = PyFrame_New( + tstate, /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +/* CIntFromPyVerify */ + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint64_t(uint64_t value) { + const uint64_t neg_one = (uint64_t) -1, const_zero = (uint64_t) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(uint64_t) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(uint64_t) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(uint64_t) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(uint64_t) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(uint64_t) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(uint64_t), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint32_t(uint32_t value) { + const uint32_t neg_one = (uint32_t) -1, const_zero = (uint32_t) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(uint32_t) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(uint32_t) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(uint32_t) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(uint32_t) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(uint32_t) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(uint32_t), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int64_t(int64_t value) { + const int64_t neg_one = (int64_t) -1, const_zero = (int64_t) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int64_t) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int64_t) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int64_t) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int64_t) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int64_t) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int64_t), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int32_t(int32_t value) { + const int32_t neg_one = (int32_t) -1, const_zero = (int32_t) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int32_t) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int32_t) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int32_t) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int32_t) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int32_t) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int32_t), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) { + const size_t neg_one = (size_t) -1, const_zero = (size_t) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(size_t) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (size_t) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (size_t) 0; + case 1: __PYX_VERIFY_RETURN_INT(size_t, digit, digits[0]) + case 2: + if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) >= 2 * PyLong_SHIFT) { + return (size_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) >= 3 * PyLong_SHIFT) { + return (size_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) >= 4 * PyLong_SHIFT) { + return (size_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (size_t) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(size_t) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (size_t) 0; + case -1: __PYX_VERIFY_RETURN_INT(size_t, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(size_t, digit, +digits[0]) + case -2: + if (8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) { + return (size_t) (((size_t)-1)*(((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) { + return (size_t) ((((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) { + return (size_t) (((size_t)-1)*(((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) { + return (size_t) ((((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) { + return (size_t) (((size_t)-1)*(((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) { + return (size_t) ((((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + } +#endif + if (sizeof(size_t) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(size_t) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + size_t val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (size_t) -1; + } + } else { + size_t val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (size_t) -1; + val = __Pyx_PyInt_As_size_t(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to size_t"); + return (size_t) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to size_t"); + return (size_t) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE int64_t __Pyx_PyInt_As_int64_t(PyObject *x) { + const int64_t neg_one = (int64_t) -1, const_zero = (int64_t) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int64_t) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int64_t, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int64_t) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int64_t) 0; + case 1: __PYX_VERIFY_RETURN_INT(int64_t, digit, digits[0]) + case 2: + if (8 * sizeof(int64_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int64_t) >= 2 * PyLong_SHIFT) { + return (int64_t) (((((int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int64_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int64_t) >= 3 * PyLong_SHIFT) { + return (int64_t) (((((((int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int64_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int64_t) >= 4 * PyLong_SHIFT) { + return (int64_t) (((((((((int64_t)digits[3]) << PyLong_SHIFT) | (int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int64_t) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int64_t) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int64_t, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int64_t) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int64_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int64_t) 0; + case -1: __PYX_VERIFY_RETURN_INT(int64_t, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int64_t, digit, +digits[0]) + case -2: + if (8 * sizeof(int64_t) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int64_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int64_t) - 1 > 2 * PyLong_SHIFT) { + return (int64_t) (((int64_t)-1)*(((((int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int64_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int64_t) - 1 > 2 * PyLong_SHIFT) { + return (int64_t) ((((((int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int64_t) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int64_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int64_t) - 1 > 3 * PyLong_SHIFT) { + return (int64_t) (((int64_t)-1)*(((((((int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int64_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int64_t) - 1 > 3 * PyLong_SHIFT) { + return (int64_t) ((((((((int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int64_t) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int64_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int64_t) - 1 > 4 * PyLong_SHIFT) { + return (int64_t) (((int64_t)-1)*(((((((((int64_t)digits[3]) << PyLong_SHIFT) | (int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int64_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int64_t) - 1 > 4 * PyLong_SHIFT) { + return (int64_t) ((((((((((int64_t)digits[3]) << PyLong_SHIFT) | (int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int64_t) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int64_t, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int64_t) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int64_t, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int64_t val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int64_t) -1; + } + } else { + int64_t val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int64_t) -1; + val = __Pyx_PyInt_As_int64_t(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int64_t"); + return (int64_t) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int64_t"); + return (int64_t) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE uint64_t __Pyx_PyInt_As_uint64_t(PyObject *x) { + const uint64_t neg_one = (uint64_t) -1, const_zero = (uint64_t) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(uint64_t) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(uint64_t, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (uint64_t) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (uint64_t) 0; + case 1: __PYX_VERIFY_RETURN_INT(uint64_t, digit, digits[0]) + case 2: + if (8 * sizeof(uint64_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint64_t) >= 2 * PyLong_SHIFT) { + return (uint64_t) (((((uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(uint64_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint64_t) >= 3 * PyLong_SHIFT) { + return (uint64_t) (((((((uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(uint64_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint64_t) >= 4 * PyLong_SHIFT) { + return (uint64_t) (((((((((uint64_t)digits[3]) << PyLong_SHIFT) | (uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (uint64_t) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(uint64_t) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(uint64_t, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(uint64_t) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(uint64_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (uint64_t) 0; + case -1: __PYX_VERIFY_RETURN_INT(uint64_t, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(uint64_t, digit, +digits[0]) + case -2: + if (8 * sizeof(uint64_t) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint64_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint64_t) - 1 > 2 * PyLong_SHIFT) { + return (uint64_t) (((uint64_t)-1)*(((((uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(uint64_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint64_t) - 1 > 2 * PyLong_SHIFT) { + return (uint64_t) ((((((uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(uint64_t) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint64_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint64_t) - 1 > 3 * PyLong_SHIFT) { + return (uint64_t) (((uint64_t)-1)*(((((((uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(uint64_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint64_t) - 1 > 3 * PyLong_SHIFT) { + return (uint64_t) ((((((((uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(uint64_t) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint64_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint64_t) - 1 > 4 * PyLong_SHIFT) { + return (uint64_t) (((uint64_t)-1)*(((((((((uint64_t)digits[3]) << PyLong_SHIFT) | (uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(uint64_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint64_t) - 1 > 4 * PyLong_SHIFT) { + return (uint64_t) ((((((((((uint64_t)digits[3]) << PyLong_SHIFT) | (uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]))); + } + } + break; + } +#endif + if (sizeof(uint64_t) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(uint64_t, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(uint64_t) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(uint64_t, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + uint64_t val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (uint64_t) -1; + } + } else { + uint64_t val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (uint64_t) -1; + val = __Pyx_PyInt_As_uint64_t(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to uint64_t"); + return (uint64_t) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to uint64_t"); + return (uint64_t) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE int32_t __Pyx_PyInt_As_int32_t(PyObject *x) { + const int32_t neg_one = (int32_t) -1, const_zero = (int32_t) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int32_t) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int32_t, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int32_t) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int32_t) 0; + case 1: __PYX_VERIFY_RETURN_INT(int32_t, digit, digits[0]) + case 2: + if (8 * sizeof(int32_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) >= 2 * PyLong_SHIFT) { + return (int32_t) (((((int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int32_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) >= 3 * PyLong_SHIFT) { + return (int32_t) (((((((int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int32_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) >= 4 * PyLong_SHIFT) { + return (int32_t) (((((((((int32_t)digits[3]) << PyLong_SHIFT) | (int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int32_t) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int32_t) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int32_t, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int32_t) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int32_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int32_t) 0; + case -1: __PYX_VERIFY_RETURN_INT(int32_t, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int32_t, digit, +digits[0]) + case -2: + if (8 * sizeof(int32_t) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) - 1 > 2 * PyLong_SHIFT) { + return (int32_t) (((int32_t)-1)*(((((int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int32_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) - 1 > 2 * PyLong_SHIFT) { + return (int32_t) ((((((int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int32_t) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) - 1 > 3 * PyLong_SHIFT) { + return (int32_t) (((int32_t)-1)*(((((((int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int32_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) - 1 > 3 * PyLong_SHIFT) { + return (int32_t) ((((((((int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int32_t) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) - 1 > 4 * PyLong_SHIFT) { + return (int32_t) (((int32_t)-1)*(((((((((int32_t)digits[3]) << PyLong_SHIFT) | (int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int32_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) - 1 > 4 * PyLong_SHIFT) { + return (int32_t) ((((((((((int32_t)digits[3]) << PyLong_SHIFT) | (int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int32_t) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int32_t, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int32_t) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int32_t, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int32_t val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int32_t) -1; + } + } else { + int32_t val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int32_t) -1; + val = __Pyx_PyInt_As_int32_t(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int32_t"); + return (int32_t) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int32_t"); + return (int32_t) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE uint32_t __Pyx_PyInt_As_uint32_t(PyObject *x) { + const uint32_t neg_one = (uint32_t) -1, const_zero = (uint32_t) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(uint32_t) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(uint32_t, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (uint32_t) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (uint32_t) 0; + case 1: __PYX_VERIFY_RETURN_INT(uint32_t, digit, digits[0]) + case 2: + if (8 * sizeof(uint32_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint32_t) >= 2 * PyLong_SHIFT) { + return (uint32_t) (((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(uint32_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint32_t) >= 3 * PyLong_SHIFT) { + return (uint32_t) (((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(uint32_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint32_t) >= 4 * PyLong_SHIFT) { + return (uint32_t) (((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (uint32_t) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(uint32_t) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(uint32_t, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(uint32_t) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(uint32_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (uint32_t) 0; + case -1: __PYX_VERIFY_RETURN_INT(uint32_t, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(uint32_t, digit, +digits[0]) + case -2: + if (8 * sizeof(uint32_t) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint32_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint32_t) - 1 > 2 * PyLong_SHIFT) { + return (uint32_t) (((uint32_t)-1)*(((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(uint32_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint32_t) - 1 > 2 * PyLong_SHIFT) { + return (uint32_t) ((((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(uint32_t) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint32_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint32_t) - 1 > 3 * PyLong_SHIFT) { + return (uint32_t) (((uint32_t)-1)*(((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(uint32_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint32_t) - 1 > 3 * PyLong_SHIFT) { + return (uint32_t) ((((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(uint32_t) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint32_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint32_t) - 1 > 4 * PyLong_SHIFT) { + return (uint32_t) (((uint32_t)-1)*(((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(uint32_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(uint32_t) - 1 > 4 * PyLong_SHIFT) { + return (uint32_t) ((((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); + } + } + break; + } +#endif + if (sizeof(uint32_t) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(uint32_t, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(uint32_t) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(uint32_t, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + uint32_t val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (uint32_t) -1; + } + } else { + uint32_t val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (uint32_t) -1; + val = __Pyx_PyInt_As_uint32_t(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to uint32_t"); + return (uint32_t) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to uint32_t"); + return (uint32_t) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE time_t __Pyx_PyInt_As_time_t(PyObject *x) { + const time_t neg_one = (time_t) -1, const_zero = (time_t) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(time_t) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(time_t, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (time_t) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (time_t) 0; + case 1: __PYX_VERIFY_RETURN_INT(time_t, digit, digits[0]) + case 2: + if (8 * sizeof(time_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(time_t) >= 2 * PyLong_SHIFT) { + return (time_t) (((((time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(time_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(time_t) >= 3 * PyLong_SHIFT) { + return (time_t) (((((((time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(time_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(time_t) >= 4 * PyLong_SHIFT) { + return (time_t) (((((((((time_t)digits[3]) << PyLong_SHIFT) | (time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (time_t) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(time_t) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(time_t, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(time_t) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(time_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (time_t) 0; + case -1: __PYX_VERIFY_RETURN_INT(time_t, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(time_t, digit, +digits[0]) + case -2: + if (8 * sizeof(time_t) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(time_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(time_t) - 1 > 2 * PyLong_SHIFT) { + return (time_t) (((time_t)-1)*(((((time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(time_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(time_t) - 1 > 2 * PyLong_SHIFT) { + return (time_t) ((((((time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(time_t) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(time_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(time_t) - 1 > 3 * PyLong_SHIFT) { + return (time_t) (((time_t)-1)*(((((((time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(time_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(time_t) - 1 > 3 * PyLong_SHIFT) { + return (time_t) ((((((((time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(time_t) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(time_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(time_t) - 1 > 4 * PyLong_SHIFT) { + return (time_t) (((time_t)-1)*(((((((((time_t)digits[3]) << PyLong_SHIFT) | (time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(time_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(time_t) - 1 > 4 * PyLong_SHIFT) { + return (time_t) ((((((((((time_t)digits[3]) << PyLong_SHIFT) | (time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0]))); + } + } + break; + } +#endif + if (sizeof(time_t) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(time_t, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(time_t) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(time_t, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + time_t val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (time_t) -1; + } + } else { + time_t val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (time_t) -1; + val = __Pyx_PyInt_As_time_t(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to time_t"); + return (time_t) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to time_t"); + return (time_t) -1; +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* FastTypeChecks */ + #if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = a->tp_base; + if (a == b) + return 1; + } + return b == &PyBaseObject_Type; +} +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (a == b) return 1; + mro = a->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(a, b); +} +#if PY_MAJOR_VERSION == 2 +static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { + PyObject *exception, *value, *tb; + int res; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&exception, &value, &tb); + res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + if (!res) { + res = PyObject_IsSubclass(err, exc_type2); + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + } + __Pyx_ErrRestore(exception, value, tb); + return res; +} +#else +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; + if (!res) { + res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + } + return res; +} +#endif +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject* exc_type) { + if (likely(err == exc_type)) return 1; + if (likely(PyExceptionClass_Check(err))) { + return __Pyx_inner_PyErr_GivenExceptionMatches2(err, NULL, exc_type); + } + return PyErr_GivenExceptionMatches(err, exc_type); +} +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *exc_type1, PyObject *exc_type2) { + if (likely(err == exc_type1 || err == exc_type2)) return 1; + if (likely(PyExceptionClass_Check(err))) { + return __Pyx_inner_PyErr_GivenExceptionMatches2(err, exc_type1, exc_type2); + } + return (PyErr_GivenExceptionMatches(err, exc_type1) || PyErr_GivenExceptionMatches(err, exc_type2)); +} +#endif + +/* CheckBinaryVersion */ + static int __Pyx_check_binary_version(void) { + char ctversion[4], rtversion[4]; + PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); + if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +/* FunctionExport */ + static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig) { + PyObject *d = 0; + PyObject *cobj = 0; + union { + void (*fp)(void); + void *p; + } tmp; + d = PyObject_GetAttrString(__pyx_m, (char *)"__pyx_capi__"); + if (!d) { + PyErr_Clear(); + d = PyDict_New(); + if (!d) + goto bad; + Py_INCREF(d); + if (PyModule_AddObject(__pyx_m, (char *)"__pyx_capi__", d) < 0) + goto bad; + } + tmp.fp = f; +#if PY_VERSION_HEX >= 0x02070000 + cobj = PyCapsule_New(tmp.p, sig, 0); +#else + cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0); +#endif + if (!cobj) + goto bad; + if (PyDict_SetItemString(d, name, cobj) < 0) + goto bad; + Py_DECREF(cobj); + Py_DECREF(d); + return 0; +bad: + Py_XDECREF(cobj); + Py_XDECREF(d); + return -1; +} + +/* InitStrings */ + static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + if (PyObject_Hash(*t->p) == -1) + PyErr_Clear(); + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#if !CYTHON_PEP393_ENABLED +static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +} +#else +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (likely(PyUnicode_IS_ASCII(o))) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +} +#endif +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { + return __Pyx_PyUnicode_AsStringAndSize(o, length); + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { +#if PY_MAJOR_VERSION >= 3 + if (PyLong_Check(result)) { + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__int__ returned non-int (type %.200s). " + "The ability to return an instance of a strict subclass of int " + "is deprecated, and may be removed in a future version of Python.", + Py_TYPE(result)->tp_name)) { + Py_DECREF(result); + return NULL; + } + return result; + } +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + type_name, type_name, Py_TYPE(result)->tp_name); + Py_DECREF(result); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x) || PyLong_Check(x))) +#else + if (likely(PyLong_Check(x))) +#endif + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + #if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = m->nb_int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = m->nb_long(x); + } + #else + if (likely(m && m->nb_int)) { + name = "int"; + res = m->nb_int(x); + } + #endif +#else + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Int(x); + } +#endif + if (likely(res)) { +#if PY_MAJOR_VERSION < 3 + if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { +#else + if (unlikely(!PyLong_CheckExact(res))) { +#endif + return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(x); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/pywrapfst.pxd b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/pywrapfst.pxd new file mode 100644 index 0000000000..ba47bd7bb7 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/pywrapfst.pxd @@ -0,0 +1,549 @@ +# See www.openfst.org for extensive documentation on this weighted +# finite-state transducer library. + + +from libc.time cimport time +from libc.time cimport time_t + +from libcpp cimport bool +from libcpp.memory cimport shared_ptr +from libcpp.memory cimport unique_ptr +from libcpp.utility cimport pair +from libcpp.vector cimport vector + +from libcpp.string cimport string +from basictypes cimport int32 +from basictypes cimport int64 +from basictypes cimport uint32 +from basictypes cimport uint64 +cimport fst as fst +from ios cimport stringstream + + + +# Exportable helper functions. + + +cdef string tostring(data, encoding=?) except * + +cdef string weight_tostring(data, encoding=?) except * + +cdef fst.ComposeFilter _get_compose_filter( + const string &compose_filter) except * + +cdef fst.DeterminizeType _get_determinize_type(const string &det_type) except * + +cdef fst.QueueType _get_queue_type(const string &queue_type) except * + +cdef fst.RandArcSelection _get_rand_arc_selection( + const string &replace_label_type) except * + +cdef fst.ReplaceLabelType _get_replace_label_type( + const string &replace_label_type, bool epsilon_on_replace) except * + + +# Weight. + + +cdef fst.WeightClass _get_WeightClass_or_One(const string &weight_type, + weight_string) except * + +cdef fst.WeightClass _get_WeightClass_or_Zero(const string &weight_type, + weight_string) except * + + +cdef class Weight(object): + + cdef unique_ptr[fst.WeightClass] _weight + + cdef void _check_weight(self) except * + + cpdef Weight copy(self) + + cpdef string to_string(self) + + cpdef string type(self) + + +cdef Weight _Zero(weight_type) + +cdef Weight _One(weight_type) + +cdef Weight _NoWeight(weight_type) + +cdef Weight _plus(Weight lhs, Weight rhs) + +cdef Weight _times(Weight lhs, Weight rhs) + +cdef Weight _divide(Weight lhs, Weight rhs) + +cdef Weight _power(Weight lhs, size_t n) + + +# SymbolTable. + +ctypedef fst.SymbolTable * SymbolTable_ptr + + +cdef class _SymbolTable(object): + + cdef fst.SymbolTable *_table + + cpdef int64 available_key(self) + + cpdef string checksum(self) + + cpdef SymbolTable copy(self) + + cpdef int64 get_nth_key(self, ssize_t pos) except * + + cpdef string labeled_checksum(self) + + cpdef bool member(self, key) + + cpdef string name(self) + + cpdef size_t num_symbols(self) + + cpdef void write(self, filename) except * + + cpdef void write_text(self, filename) except * + + +cdef class _EncodeMapperSymbolTable(_SymbolTable): + + cdef shared_ptr[fst.EncodeMapperClass] _encoder + + +cdef class _FstSymbolTable(_SymbolTable): + + cdef shared_ptr[fst.FstClass] _fst + + +cdef class _MutableSymbolTable(_SymbolTable): + + cpdef int64 add_symbol(self, symbol, int64 key=?) + + cpdef void add_table(self, _SymbolTable syms) + + cpdef void set_name(self, new_name) except * + + +cdef class _MutableFstSymbolTable(_MutableSymbolTable): + + cdef shared_ptr[fst.MutableFstClass] _mfst + + +cdef class SymbolTable(_MutableSymbolTable): + + cdef unique_ptr[fst.SymbolTable] _smart_table + + +cdef _EncodeMapperSymbolTable _init_EncodeMapperSymbolTable( + fst.SymbolTable *table, shared_ptr[fst.EncodeMapperClass] encoder) + + +cdef _FstSymbolTable _init_FstSymbolTable(fst.SymbolTable *table, + shared_ptr[fst.FstClass] ifst) + + +cdef _MutableFstSymbolTable _init_MutableFstSymbolTable(fst.SymbolTable *table, + shared_ptr[fst.MutableFstClass] ifst) + + +cdef SymbolTable _init_SymbolTable(fst.SymbolTable *table) + + + +cdef class SymbolTableIterator(object): + + cdef shared_ptr[fst.SymbolTable] _table + cdef unique_ptr[fst.SymbolTableIterator] _siter + + cpdef bool done(self) + + cpdef void next(self) + + cpdef void reset(self) + + cpdef string symbol(self) + + cpdef int64 value(self) + + +# EncodeMapper. + + +cdef class EncodeMapper(object): + + cdef shared_ptr[fst.EncodeMapperClass] _encoder + + cpdef string arc_type(self) + + cpdef uint32 flags(self) + + cpdef _EncodeMapperSymbolTable input_symbols(self) + + cpdef _EncodeMapperSymbolTable output_symbols(self) + + cpdef uint64 properties(self, uint64 mask) + + cpdef void set_input_symbols(self, _SymbolTable syms) except * + + cpdef void set_output_symbols(self, _SymbolTable syms) except * + + cpdef string weight_type(self) + + +# Fst. + + +ctypedef fst.FstClass * FstClass_ptr +ctypedef fst.MutableFstClass * MutableFstClass_ptr +ctypedef fst.VectorFstClass * VectorFstClass_ptr + + +cdef class _Fst(object): + + cdef shared_ptr[fst.FstClass] _fst + + cpdef string arc_type(self) + + cpdef ArcIterator arcs(self, int64 state) + + cpdef _Fst copy(self) + + cpdef void draw(self, filename, _SymbolTable isymbols=?, + _SymbolTable osymbols=?, SymbolTable ssymbols=?, + bool acceptor=?, title=?, double width=?, + double height=?, bool portrait=?, bool vertical=?, + double ranksep=?, double nodesep=?, int32 fontsize=?, + int32 precision=?, float_format=?, + bool show_weight_one=?) + + cpdef Weight final(self, int64 state) + + cpdef string fst_type(self) + + cpdef _FstSymbolTable input_symbols(self) + + cpdef size_t num_arcs(self, int64 state) except * + + cpdef size_t num_input_epsilons(self, int64 state) except * + + cpdef size_t num_output_epsilons(self, int64 state) except * + + cpdef _FstSymbolTable output_symbols(self) + + cpdef uint64 properties(self, uint64 mask, bool test) + + cpdef int64 start(self) + + cpdef StateIterator states(self) + + cpdef string text(self, _SymbolTable isymbols=?, _SymbolTable osymbols=?, + _SymbolTable ssymbols=?, bool acceptor=?, + bool show_weight_one=?, missing_sym=?) + + cpdef bool verify(self) + + cpdef string weight_type(self) + + cpdef void write(self, filename) except * + + cpdef string write_to_string(self) + + +cdef class _MutableFst(_Fst): + + cdef shared_ptr[fst.MutableFstClass] _mfst + + cdef void _check_mutating_imethod(self) except * + + cdef void _add_arc(self, int64 state, Arc arc) except * + + cpdef int64 add_state(self) except * + + cdef void _arcsort(self, sort_type=?) except * + + cdef void _closure(self, bool closure_plus=?) except * + + cdef void _concat(self, _Fst ifst) except * + + cdef void _connect(self) except * + + cdef void _decode(self, EncodeMapper) except * + + cdef void _delete_arcs(self, int64 state, size_t n=?) except * + + cdef void _delete_states(self, states=?) except * + + cdef void _encode(self, EncodeMapper) except * + + cdef void _invert(self) except * + + cdef void _minimize(self, float delta=?, bool allow_nondet=?) except * + + cpdef MutableArcIterator mutable_arcs(self, int64 state) + + cpdef int64 num_states(self) + + cdef void _project(self, bool project_output=?) except * + + cdef void _prune(self, float delta=?, int64 nstate=?, weight=?) except * + + cdef void _push(self, float delta=?, bool remove_total_weight=?, + bool to_final=?) except * + + cdef void _relabel_pairs(self, ipairs=?, opairs=?) except * + + cdef void _relabel_tables(self, _SymbolTable old_isymbols=?, + _SymbolTable new_isymbols=?, unknown_isymbol=?, + bool attach_new_isymbols=?, + _SymbolTable old_osymbols=?, _SymbolTable new_osymbols=?, + unknown_osymbol=?, bool attach_new_osymbols=?) except * + + cdef void _reserve_arcs(self, int64 state, size_t n) except * + + cdef void _reserve_states(self, int64 n) except * + + cdef void _reweight(self, potentials, bool to_final=?) except * + + cdef void _rmepsilon(self, queue_type=?, bool connect=?, weight=?, + int64 nstate=?, float delta=?) except * + + cdef void _set_final(self, int64 state, weight=?) except * + + cdef void _set_properties(self, uint64 props, uint64 mask) + + cdef void _set_start(self, int64 state) except * + + cdef void _set_input_symbols(self, _SymbolTable syms) except * + + cdef void _set_output_symbols(self, _SymbolTable syms) except * + + cdef void _topsort(self) except * + + cdef void _union(self, _Fst ifst) except * + + +# Fst construction helpers. + + +cdef _Fst _init_Fst(FstClass_ptr tfst) + +cdef _MutableFst _init_MutableFst(MutableFstClass_ptr tfst) + +cdef _Fst _init_XFst(FstClass_ptr tfst) + +cdef _MutableFst _create_Fst(arc_type=?) + +cpdef _Fst _read(filename) + +cpdef _Fst _read_from_string(State) + + +# Iterators. + + +cdef class Arc(object): + + cdef unique_ptr[fst.ArcClass] _arc + + cpdef Arc copy(self) + + +cdef Arc _init_Arc(const fst.ArcClass &arc) + + +cdef class ArcIterator(object): + + cdef shared_ptr[fst.FstClass] _fst + cdef unique_ptr[fst.ArcIteratorClass] _aiter + + cpdef bool done(self) + + cpdef uint32 flags(self) + + cpdef void next(self) + + cpdef size_t position(self) + + cpdef void reset(self) + + cpdef void seek(self, size_t a) + + cpdef void set_flags(self, uint32 flags, uint32 mask) + + cpdef object value(self) + + +cdef class MutableArcIterator(object): + + cdef shared_ptr[fst.MutableFstClass] _mfst + cdef unique_ptr[fst.MutableArcIteratorClass] _aiter + + cpdef bool done(self) + + cpdef uint32 flags(self) + + cpdef void next(self) + + cpdef size_t position(self) + + cpdef void reset(self) + + cpdef void seek(self, size_t a) + + cpdef void set_flags(self, uint32 flags, uint32 mask) + + cpdef void set_value(self, Arc arc) + + cpdef object value(self) + + +cdef class StateIterator(object): + + cdef shared_ptr[fst.FstClass] _fst + cdef unique_ptr[fst.StateIteratorClass] _siter + + cpdef bool done(self) + + cpdef void next(self) + + cpdef void reset(self) + + cpdef int64 value(self) + + +# Constructive operations on Fst. + + +cdef _Fst _map(_Fst ifst, float delta=?, map_type=?, double power=?, weight=?) + +cpdef _Fst arcmap(_Fst ifst, float delta=?, map_type=?, double power=?, weight=?) + +cpdef _MutableFst compose(_Fst ifst1, _Fst ifst2, compose_filter=?, + bool connect=?) + +cpdef _Fst convert(_Fst ifst, fst_type=?) + +cpdef _MutableFst determinize(_Fst ifst, float delta=?, det_type=?, + int64 nstate=?, int64 subsequential_label=?, + weight=?, bool increment_subsequential_label=?) + +cpdef _MutableFst difference(_Fst ifst1, _Fst ifst2, compose_filter=?, + bool connect=?) + +cpdef _MutableFst disambiguate(_Fst ifst, float delta=?, int64 nstate=?, + int64 subsequential_label=?, weight=?) + +cpdef _MutableFst epsnormalize(_Fst ifst, bool eps_norm_output=?) + +cpdef bool equal(_Fst ifst1, _Fst ifst2, float delta=?) + +cpdef bool equivalent(_Fst ifst1, _Fst ifst2, float delta=?) except * + +cpdef _MutableFst intersect(_Fst ifst1, _Fst ifst2, compose_filter=?, + bool connect=?) + +cpdef bool isomorphic(_Fst ifst1, _Fst ifst2, float delta=?) + +cpdef _MutableFst prune(_Fst ifst, float delta=?, int64 nstate=?, + weight=?) + +cpdef _MutableFst push(_Fst ifst, float delta=?, bool push_weights=?, + bool push_labels=?, bool remove_common_affix=?, + bool remove_total_weight=?, bool to_final=?) + +cpdef bool randequivalent(_Fst ifst1, _Fst ifst2, int32 npath=?, + float delta=?, time_t seed=?, select=?, + int32 max_length=?) except * + +cpdef _MutableFst randgen(_Fst ifst, int32 npath=?, time_t seed=?, + select=?, int32 max_length=?, + bool remove_total_weight=?, bool weighted=?) + +cdef fst.ReplaceLabelType _get_replace_label_type(string rlt, + bool epsilon_on_replace) except * + +cpdef _MutableFst replace(pairs, call_arc_labeling=?, return_arc_labeling=?, + bool epsilon_on_replace=?, int64 return_label=?) + +cpdef _MutableFst reverse(_Fst ifst, bool require_superinitial=?) + +cdef vector[fst.WeightClass] *_shortestdistance(_Fst ifst, float delta=?, + int64 nstate=?, queue_type=?, + bool reverse=?) except * + +cpdef _MutableFst shortestpath(_Fst ifst, float delta=?, int32 nshortest=?, + int64 nstate=?, queue_type=?, bool unique=?, + weight=?) + +cpdef _Fst statemap(_Fst ifst, map_type) + +cpdef _MutableFst synchronize(_Fst ifst) + + +# Compiler. + + +cdef class Compiler(object): + + cdef unique_ptr[stringstream] _sstrm + cdef string _fst_type + cdef string _arc_type + cdef const fst.SymbolTable *_isymbols + cdef const fst.SymbolTable *_osymbols + cdef const fst.SymbolTable *_ssymbols + cdef bool _acceptor + cdef bool _keep_isymbols + cdef bool _keep_osymbols + cdef bool _keep_state_numbering + cdef bool _allow_negative_labels + + cpdef _Fst compile(self) + + cpdef void write(self, expression) + + +# FarReader. + +cdef class FarReader(object): + + cdef unique_ptr[fst.FarReaderClass] _reader + + cpdef string arc_type(self) + + cpdef bool done(self) + + cpdef bool error(self) + + cpdef string far_type(self) + + cpdef bool find(self, key) except * + + cpdef _Fst get_fst(self) + + cpdef string get_key(self) + + cpdef void next(self) + + cpdef void reset(self) + + +# FarWriter. + +cdef class FarWriter(object): + + cdef unique_ptr[fst.FarWriterClass] _writer + + cpdef string arc_type(self) + + cdef void close(self) + + cpdef void add(self, key, _Fst ifst) except * + + cpdef bool error(self) + + cpdef string far_type(self) diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/pywrapfst.pyx b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/pywrapfst.pyx new file mode 100644 index 0000000000..80804a3128 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/python/pywrapfst.pyx @@ -0,0 +1,4479 @@ +#cython: nonecheck=True +# See www.openfst.org for extensive documentation on this weighted +# finite-state transducer library. + + +"""Python interface to the FST scripting API. + +Operations which construct new FSTs are implemented as traditional functions, as +are two-argument boolean functions like `equal` and `equivalent`. Destructive +operations---those that mutate an FST, in place---are instance methods, as is +`write`. Operator overloading is not used. The following example, based on +Mohri et al. 2002, shows the construction of an ASR system given a pronunciation +lexicon L, grammar G, a transducer from context-dependent phones to +context-independent phones C, and an HMM set H: + + L = fst.Fst.read("L.fst") + G = fst.Fst.read("G.fst") + C = fst.Fst.read("C.fst") + H = fst.Fst.read("H.fst") + LG = fst.determinize(fst.compose(L, G)) + CLG = fst.determinize(fst.compose(C, LG)) + HCLG = fst.determinize(fst.compose(H, CLG)) + HCLG.minimize() # NB: works in-place. + +Python variables here use snake_case and constants are in all caps, minus the +normal `k` prefix. +""" + +# Overview of the file: +# +# * Imports +# * Custom exceptions +# * General helpers +# * Weight and helpers +# * _SymbolTable, _EncodeMapperSymbolTable, _FstSymbolTable, +# _MutableFstSymbolTable, SymbolTable, and helpers +# * SymbolTableIterator +# * EncodeMapper +# * _Fst, _MutableFst, Fst, and helpers +# * FST properties +# * Arc, ArcIterator, and MutableArcIterator +# * StateIterator +# * FST operations +# * Compiler +# * FarReader and FarWriter +# * Cleanup operations for module entrance and exit. +# +# TODO(kbg): Try breaking this apart into smaller pieces. +# +# A few of the more idiosyncratic choices made here are due to "impedance +# mismatches" between C++ and Python, as follows. +# +# Another issue is that due to differences in C++ and Python scope rules, most +# C++ class instances have to be heap-allocated. Since all are packed into +# Python class instances, Python destructors are used to semi-automatically +# free C++ instances. The one exception are the various `...Options` structs. +# All that is included here are the constructors; there is no need to include +# the names of the struct members. Cython does not draw any meaningful +# distinction between structs and C++ classes, so these look just like class +# definitions. +# +# Cython's type annotations (e.g., `string`) are used when the variables will +# be sent as arguments to C++ functions, but are not used for variables used +# within the module. +# +# Internal functions which may raise a Python error do not have a C++ return +# type simply because this leads the C++ compiler to think that the resulting +# value could be used before it is populated. + + +## Imports. + +# C imports. +from libc.stdint cimport INT32_MAX +from libc.stdint cimport SIZE_MAX +from posix.unistd cimport getpid + +# C++ imports. +from libcpp cimport bool +from libcpp.cast cimport const_cast +from libcpp.cast cimport static_cast + +# Our C++ imports. +from ios cimport ofstream +from memory cimport static_pointer_cast + +# Cython operator workarounds. +from cython.operator cimport address as addr # &foo +from cython.operator cimport dereference as deref # *foo +from cython.operator cimport preincrement as inc # ++foo + +# Python imports. +import atexit +import numbers +import subprocess +import logging + + +# TODO(kbg): Figure out how to access static class variables so I don't have +# to do it this way. +kNoSymbol = -1 + + +## Custom exceptions. + + +class FstError(Exception): + + pass + + +class FstArgError(FstError, ValueError): + + pass + + +class FstBadWeightError(FstError, ValueError): + + pass + + +class FstDeletedConstructorError(FstError, RuntimeError): + + pass + + +class FstIndexError(FstError, IndexError): + + pass + + +class FstIOError(FstError, IOError): + + pass + + +class FstOpError(FstError, RuntimeError): + + pass + + +## General helpers. + + +cdef string tostring(data, encoding="utf8") except *: + """Converts strings to bytestrings. + + This function converts Python bytestrings and Unicode strings to bytestrings + encoded in UTF-8. It is used to process most Python string arguments before + passing them to the lower-level library. + + Args: + data: A Unicode string or bytestring. + encoding: The desired encoding, defaulting to UTF-8. + + Returns: + A bytestring. + + Raises: + FstArgError: Cannot encode string. + UnicodeEncodeError. + + This function is not visible to Python users. + """ + # A Python bytestring can be implicitly cast to a C++ string. + if isinstance(data, bytes): + return data + elif isinstance(data, unicode): + return data.encode(encoding) + raise FstArgError("Cannot encode as string: {!r}".format(data)) + + +cdef string weight_tostring(data, encoding="utf8") except *: + """Converts strings or numerics to bytestrings. + + This function converts Python bytestrings, Unicode strings, and numerics + which can be cast to floats to bytestrings encoded in UTF-8. It is used to + process Python string arguments so they can be used to construct Weight + objects. In most cases, weights are underlyingly floating-point, but since + not all weights are, they can only be constructed using a string. + + Args: + data: A Unicode string, bytestring, or type which can be converted to a + Python float. + + Returns: + A bytestring. + + Raise: + FstArgError: Cannot encode string. + ValueError: Invalid literal for float. + UnicodeEncodeError. + + This function is not visible to Python users. + """ + # A Python bytestring can be implicitly cast to a C++ string. + if isinstance(data, bytes): + return data + elif isinstance(data, unicode): + return data.encode(encoding) + elif isinstance(data, numbers.Number): + return str(data).encode(encoding) + raise FstArgError("Cannot encode as string: {!r}".format(data)) + + +cdef fst.ComposeFilter _get_compose_filter( + const string &compose_filter) except *: + """Matches string with the appropriate ComposeFilter enum value. + + This function takes a string argument and returns the matching ComposeFilter + enum value used to initialize ComposeOptions instances. ComposeOptions is used + by difference and intersection in addition to composition. + + Args: + compose_filter: A string matching a known composition filter; one of: + "alt_sequence", "auto", "match", "null", "sequence", "trivial". + + Returns: + A ComposeFilter enum value. + + Raises: + FstArgError: Unknown compose filter type. + + This function is not visible to Python users. + """ + cdef fst.ComposeFilter compose_filter_enum + if not fst.GetComposeFilter(compose_filter, addr(compose_filter_enum)): + raise FstArgError("Unknown compose filter type: {!r}".format( + compose_filter)) + return compose_filter_enum + + +cdef fst.DeterminizeType _get_determinize_type(const string &det_type) except *: + """Matches string with the appropriate DeterminizeType enum value. + + Args: + det_type: A string matching a known determinization type; one of: + "functional", "nonfunctional", "disambiguate". + + Returns: + A DeterminizeType enum value. + + Raises: + FstArgError: Unknown determinization type. + + This function is not visible to Python users. + """ + cdef fst.DeterminizeType det_type_enum + if not fst.GetDeterminizeType(det_type, addr(det_type_enum)): + raise FstArgError("Unknown determinization type: {!r}".format(det_type)) + return det_type_enum + + +cdef fst.QueueType _get_queue_type(const string &queue_type) except *: + """Matches string with the appropriate QueueType enum value. + + This function takes a string argument and returns the matching QueueType enum + value passed to the RmEpsilonOptions constructor. + + Args: + queue_type: A string matching a known queue type; one of: "auto", "fifo", + "lifo", "shortest", "state", "top". + + Returns: + A QueueType enum value. + + Raises: + FstArgError: Unknown queue type. + + This function is not visible to Python users. + """ + cdef fst.QueueType queue_type_enum + if not fst.GetQueueType(queue_type, addr(queue_type_enum)): + raise FstArgError("Unknown queue type: {!r}".format(queue_type)) + return queue_type_enum + + +cdef fst.RandArcSelection _get_rand_arc_selection( + const string &select) except *: + """Matches string with the appropriate RandArcSelection enum value. + + This function takes a string argument and returns the matching + RandArcSelection enum value passed to the RandGenOptions constructor. + + Args: + select: A string matching a known random arc selection type; one of: + "uniform", "log_prob", "fast_log_prob". + + Returns: + A RandArcSelection enum value. + + Raises: + FstArgError: Unknown random arc selection type. + + This function is not visible to Python users. + """ + cdef fst.RandArcSelection select_enum + if not fst.GetRandArcSelection(select, addr(select_enum)): + raise FstArgError("Unknown random arc selection type: {!r}".format(select)) + return select_enum + + +cdef fst.ReplaceLabelType _get_replace_label_type( + const string &replace_label_type, bool epsilon_on_replace) except *: + """Matches string with the appropriate ReplaceLabelType enum value. + + This function takes a string argument and returns the matching + ReplaceLabelType enum value passed to the ReplaceOptions constructor. + + Args: + replace_label_type: A string matching a known replace label type; one of: + "neither", "input", "output", "both". + epsilon_on_replace: Should call/return arcs be epsilon arcs? + + Returns: + A ReplaceLabelType enum value. + + Raises: + FstArgError: Unknown replace label type. + + This function is not visible to Python users. + """ + cdef fst.ReplaceLabelType replace_label_type_enum + if not fst.GetReplaceLabelType(replace_label_type, epsilon_on_replace, + addr(replace_label_type_enum)): + raise FstArgError("Unknown replace label type: {!r}".format( + replace_label_type)) + return replace_label_type_enum + + +## Weight and helpers. + + +cdef class Weight(object): + + """ + Weight(weight_type, weight_string) + + FST weight class. + + This class represents an FST weight. When passed as an argument to an FST + operation, it should have the weight type of the input FST(s) to said + operation. + + Args: + weight_type: A string indicating the weight type. + weight_string: A string indicating the underlying weight. + + Raises: + FstArgError: Weight type not found. + FstBadWeightError: Invalid weight. + """ + + def __repr__(self): + return "<{} Weight {} at 0x{:x}>".format(self.type(), self.to_string(), + id(self)) + + def __str__(self): + return self.to_string() + + # This attempts to convert the string form into a float, raising + # ValueError when that is not appropriate. + + def __float__(self): + return float(self.to_string()) + + def __init__(self, weight_type, weight): + self._weight.reset(new fst.WeightClass(tostring(weight_type), + weight_tostring(weight))) + self._check_weight() + + cdef void _check_weight(self) except *: + if self.type() == b"none": + raise FstArgError("Weight type not found") + if self.to_string() == b"BadNumber": + raise FstBadWeightError("Invalid weight") + + cpdef Weight copy(self): + """ + copy(self) + + Returns a copy of the Weight. + """ + cdef Weight result = Weight.__new__(Weight) + result._weight.reset(new fst.WeightClass(deref(self._weight))) + return result + + # To get around the inability to declare cdef class methods, we define the + # C++ part out-of-class and then call it from within. + + @classmethod + def Zero(cls, weight_type): + """ + Weight.Zero(weight_type) + + Constructs semiring zero. + """ + return _Zero(weight_type) + + @classmethod + def One(cls, weight_type): + """ + Weight.One(weight_type) + + Constructs semiring One. + """ + return _One(weight_type) + + @classmethod + def NoWeight(cls, weight_type): + """ + Weight.NoWeight(weight_type) + + Constructs a non-member weight in the semiring. + """ + return _NoWeight(weight_type) + + def __eq__(Weight w1, Weight w2): + return fst.Eq(deref(w1._weight), deref(w2._weight)) + + def __ne__(Weight w1, Weight w2): + return not w1 == w2 + + cpdef string to_string(self): + return self._weight.get().ToString() + + cpdef string type(self): + """type(self) + + Returns a string indicating the weight type. + """ + return self._weight.get().Type() + + +cdef Weight _plus(Weight lhs, Weight rhs): + cdef Weight result = Weight.__new__(Weight) + result._weight.reset(new fst.WeightClass(fst.Plus(deref(lhs._weight), + deref(rhs._weight)))) + return result + + +def plus(Weight lhs, Weight rhs): + """ + plus(lhs, rhs) + + Computes the sum of two Weights in the same semiring. + + This function computes lhs \oplus rhs, raising an exception if lhs and rhs + are not in the same semiring. + + Args: + lhs: Left-hand side Weight. + rhs: Right-hand side Weight. + + Returns: + A Weight object. + + Raises: + FstArgError: Weight type not found (or not in same semiring). + FstBadWeightError: invalid weight. + """ + cdef Weight result = _plus(lhs, rhs) + result._check_weight() + return result + + +cdef Weight _times(Weight lhs, Weight rhs): + cdef Weight result = Weight.__new__(Weight) + result._weight.reset(new fst.WeightClass(fst.Times(deref(lhs._weight), + deref(rhs._weight)))) + return result + + +def times(Weight lhs, Weight rhs): + """ + times(lhs, rhs) + + Computes the product of two Weights in the same semiring. + + This function computes lhs \otimes rhs, raising an exception if lhs and rhs + are not in the same semiring. + + Args: + lhs: Left-hand side Weight. + rhs: Right-hand side Weight. + + Returns: + A Weight object. + + Raises: + FstArgError: Weight type not found (or not in same semiring). + FstBadWeightError: Invalid weight. + """ + cdef Weight result = _times(lhs, rhs) + result._check_weight() + return result + + +cdef Weight _divide(Weight lhs, Weight rhs): + cdef Weight result = Weight.__new__(Weight) + result._weight.reset(new fst.WeightClass(fst.Divide(deref(lhs._weight), + deref(rhs._weight)))) + return result + + +def divide(Weight lhs, Weight rhs): + """ + divide(lhs, rhs) + + Computes the quotient of two Weights in the same semiring. + + This function computes lhs \oslash rhs, raising an exception if lhs and rhs + are not in the same semiring. As there is no way to specify whether to use + left vs. right division, this assumes a commutative semiring in which these + are equivalent operations. + + Args: + lhs: Left-hand side Weight. + rhs: Right-hand side Weight. + + Returns: + A Weight object. + + Raises: + FstArgError: Weight type not found (or not in same semiring). + FstBadWeightError: Invalid weight. + """ + cdef Weight result = _divide(lhs, rhs) + result._check_weight() + return result + + +cdef Weight _power(Weight w, size_t n): + cdef Weight result = Weight.__new__(Weight) + result._weight.reset(new fst.WeightClass(fst.Power(deref(w._weight), n))) + return result + + +def power(Weight w, size_t n): + """ + power(lhs, rhs) + + Computes the iterated product of a weight. + + Args: + w: The weight. + n: The power. + + Returns: + A Weight object. + + Raises: + FstArgError: Weight type not found (or not in same semiring). + FstBadWeightError: Invalid weight. + """ + cdef Weight result = _power(w, n) + result._check_weight() + return result + + +cdef fst.WeightClass _get_WeightClass_or_Zero(const string &weight_type, + weight) except *: + """Converts weight string to a WeightClass. + + This function constructs a WeightClass instance of the desired weight type. + If the first argument is null, the weight is set to semiring Zero. + + Args: + weight_type: A string denoting the desired weight type. + weight: A object indicating the desired weight; if omitted, the weight is + set to semiring Zero. + + Returns: + A WeightClass object. + + This function is not visible to Python users. + """ + cdef fst.WeightClass result + if weight is None: + result = fst.WeightClass.Zero(weight_type) + elif isinstance(weight, Weight): + result = deref( ( weight)._weight.get()) + else: + result = fst.WeightClass(weight_type, weight_tostring(weight)) + if result.ToString() == b"BadNumber": + raise FstBadWeightError(weight_tostring(weight)) + return result + + +cdef fst.WeightClass _get_WeightClass_or_One(const string &weight_type, + weight) except *: + """Converts weight string to a WeightClass. + + This function constructs a WeightClass instance of the desired weight type. + If the first argument is null, the weight is set to semiring One. + + Args: + weight_type: A string denoting the desired weight type. + weight: A object indicating the desired weight; if omitted, the weight is + set to semiring One. + + Returns: + A WeightClass object. + + This function is not visible to Python users. + """ + cdef fst.WeightClass result + if weight is None: + result = fst.WeightClass.One(weight_type) + elif isinstance(weight, Weight): + result = deref( ( weight)._weight.get()) + else: + result = fst.WeightClass(weight_type, weight_tostring(weight)) + if result.ToString() == b"BadNumber": + raise FstBadWeightError(weight_tostring(weight)) + return result + + +cdef Weight _Zero(weight_type): + cdef Weight result = Weight.__new__(Weight) + result._weight.reset(new fst.WeightClass(fst.WeightClass.Zero( + tostring(weight_type)))) + if result._weight.get().Type() == b"none": + raise FstArgError("Weight type not found") + return result + + +cdef Weight _One(weight_type): + cdef Weight result = Weight.__new__(Weight) + result._weight.reset(new fst.WeightClass( + fst.WeightClass.One(tostring(weight_type)))) + if result._weight.get().Type() == b"none": + raise FstArgError("Weight type not found") + return result + + +cdef Weight _NoWeight(weight_type): + cdef Weight result = Weight.__new__(Weight) + result._weight.reset(new fst.WeightClass( + fst.WeightClass.NoWeight(tostring(weight_type)))) + return result + + +## _SymbolTable, _MutableSymbolTable, _EncodeMapperSymbolTable, _FstSymbolTable, +## _MutableFstSymbolTable, SymbolTable, and helpers. +# +# SymbolTable hierarchy: +# +# _SymbolTable: abstract base class; has-a SymbolTable* +# _EncodeMapperSymbolTable(_SymbolTable): constant symbol table returned by +# EncodeMapper.input_symbols/output_symbols +# _FstSymbolTable(_SymbolTable): constant symbol table returned by +# _Fst.input_symbols/output_symbols +# +# _MutableSymbolTable(_SymbolTable): abstract base class adding mutation methods +# _MutableFstSymbolTable(_MutableSymbolTable): mutable symbol table returned by +# _MutableFst.mutable_input_symbols/mutable_output_symbols +# SymbolTable(_MutableSymbolTable): adds constructor + + +cdef class _SymbolTable(object): + + """ + (No constructor.) + + Base class for the symbol table hierarchy. + + This class is the base class for SymbolTable. It has a "deleted" constructor + and implementations for the const methods of the wrapped SymbolTable. + """ + + # NB: Do not expose any non-const methods of the wrapped SymbolTable here. + # Doing so will allow undefined behavior. + + def __init__(self): + raise FstDeletedConstructorError( + "Cannot construct {}".format(self.__class__.__name__)) + + def __iter__(self): + return SymbolTableIterator(self) + + cpdef int64 available_key(self): + """ + available_key(self) + + Returns an integer indicating the next available key index in the table. + """ + return self._table.AvailableKey() + + cpdef string checksum(self): + """ + checksum(self) + + Returns a string indicating the label-agnostic MD5 checksum for the table. + """ + return self._table.CheckSum() + + cpdef SymbolTable copy(self): + """ + copy(self) + + Returns a mutable copy of the SymbolTable. + """ + return _init_SymbolTable(self._table.Copy()) + + def find(self, key): + """ + find(self, key) + + Given a symbol or index, finds the other one. + + This method returns the index associated with a symbol key, or the symbol + associated with a index key. + + Args: + key: Either a string or an index. + + Returns: + If the key is a string, the associated index or NO_LABEL if not found; if + the key is an integer, the associated symbol or an empty string if + not found. + """ + try: + return self._table.FindIndex(tostring(key)) + except FstArgError: + return self._table.FindSymbol(key) + + cpdef int64 get_nth_key(self, ssize_t pos) except *: + """ + get_nth_key(self, pos) + + Retrieves the integer index of the n-th key in the table. + + Args: + pos: The n-th key to retrieve. + + Returns: + The integer index of the n-th key, or NO_LABEL if not found. + """ + return self._table.GetNthKey(pos) + + cpdef string labeled_checksum(self): + """ + labeled_checksum(self) + + Returns a string indicating the label-dependent MD5 checksum for the table. + """ + return self._table.LabeledCheckSum() + + cpdef bool member(self, key): + """ + member(self, key) + + Given a symbol or index, returns whether it is found in the table. + + This method returns a boolean indicating whether the given symbol or index + is present in the table. If one intends to perform subsequent lookup, it is + better to simply call the find method, catching the KeyError. + + Args: + key: Either a string or an index. + + Returns: + Whether or not the key is present (as a string or a index) in the table. + """ + try: + return self._table.MemberSymbol(tostring(key)) + except FstArgError: + return self._table.MemberIndex(key) + + def __contains__(self, key): + return self.member(key) + + cpdef string name(self): + """ + name(self) + + Returns the symbol table's name. + """ + return self._table.Name() + + cpdef size_t num_symbols(self): + """ + num_symbols(self) + + Returns the number of symbols in the symbol table. + """ + return self._table.NumSymbols() + + cpdef void write(self, filename) except *: + """ + write(self, filename) + + Serializes symbol table to a file. + + This methods writes the SymbolTable to a file in binary format. + + Args: + filename: The string location of the output file. + + Raises: + FstIOError: Write failed. + """ + if not self._table.Write(tostring(filename)): + raise FstIOError("Write failed: {!r}".format(filename)) + + cpdef void write_text(self, filename) except *: + """ + write_text(self, filename) + + Writes symbol table to text file. + + This method writes the SymbolTable to a file in human-readable format. + + Args: + filename: The string location of the output file. + + Raises: + FstIOError: Write failed. + """ + if not self._table.WriteText(tostring(filename)): + raise FstIOError("Write failed: {!r}".format(filename)) + + +cdef class _EncodeMapperSymbolTable(_SymbolTable): + + """ + (No constructor.) + + Immutable SymbolTable class for tables stored in an EncodeMapper. + + This class wraps a library const SymbolTable and exposes const methods of the + wrapped object. It is only to be returned by method, never constructed + directly. + """ + + # NB: Do not expose any non-const methods of the wrapped SymbolTable here. + # Doing so will allow undefined behavior. + + def __repr__(self): + return "".format(self.name(), + id(self)) + + +cdef class _FstSymbolTable(_SymbolTable): + + """ + (No constructor.) + + Mutable SymbolTable class for tables stored in a mutable FST. + + This class wraps a library SymbolTable and exposes methods of the wrapped + object. It is only to be returned by method, never constructed directly. + """ + + # NB: Do not expose any non-const methods of the wrapped SymbolTable here. + # Doing so will allow undefined behavior. + + def __repr__(self): + return "".format(self.name(), + id(self)) + + +cdef class _MutableSymbolTable(_SymbolTable): + + """ + (No constructor.) + + Base class for mutable symbol tables. + + This class is the base class for a mutable SymbolTable. It has a "deleted" + constructor and implementations of all methods of the wrapped SymbolTable. + """ + + cpdef int64 add_symbol(self, symbol, int64 key=kNoSymbol): + """ + add_symbol(self, symbol, key=NO_SYMBOL) + + Adds a symbol to the table and returns the index. + + This method adds a symbol to the table. The caller can optionally + specify a non-negative integer index for the key. + + Args: + symbol: A symbol string. + key: An index for the symbol; if not specified, the next index will be + used. + + Returns: + The integer key of the new symbol. + """ + cdef string symbol_string = tostring(symbol) + if key != kNoSymbol: + return self._table.AddSymbol(symbol_string, key) + else: + return self._table.AddSymbol(symbol_string) + + cpdef void add_table(self, _SymbolTable syms): + """ + add_table(self, syms) + + Adds another SymbolTable to this table. + + This method merges another symbol table into the current table. All key + values will be offset by the current available key. + + Args: + syms: A SymbolTable to be merged with the current table. + """ + self._table.AddTable(deref(syms._table)) + + cpdef void set_name(self, new_name) except *: + self._table.SetName(tostring(new_name)) + + +cdef class _MutableFstSymbolTable(_MutableSymbolTable): + """ + (No constructor.) + + Mutable SymbolTable assigned to an FST. + """ + + def __repr__(self): + return "".format(self.name(), id(self)) + + +cdef class SymbolTable(_MutableSymbolTable): + + """ + SymbolTable(name="") + + Mutable SymbolTable class. + + This class wraps the library SymbolTable and exposes both const (i.e., + access) and non-const (i.e., mutation) methods of wrapped object. + + Unlike other classes in the hierarchy, it has a working constructor and can be + used to programmatically construct a SymbolTable in memory. + + Args: + name: An optional string indicating the table's name. + """ + + def __repr__(self): + return "".format(self.name(), id(self)) + + def __init__(self, name=b""): + self._table = new fst.SymbolTable(tostring(name)) + self._smart_table.reset(self._table) + + @classmethod + def read(cls, filename): + """ + SymbolTable.read(filename) + + Reads symbol table from binary file. + + This class method creates a new SymbolTable from a symbol table binary file. + + Args: + filename: The string location of the input binary file. + + Returns: + A new SymbolTable instance. + + See also: `SymbolTable.read_fst`, `SymbolTable.read_text`. + """ + cdef fst.SymbolTable *tsyms = fst.SymbolTable.Read(tostring(filename)) + if tsyms == NULL: + raise FstIOError("Read failed: {!r}".format(filename)) + return _init_SymbolTable(tsyms) + + @classmethod + def read_text(cls, filename, bool allow_negative_labels=False): + """ + SymbolTable.read_text(filename) + + Reads symbol table from text file. + + This class method creates a new SymbolTable from a symbol table text file. + + Args: + filename: The string location of the input text file. + allow_negative_labels: Should negative labels be allowed? (Not + recommended; may cause conflicts). + + Returns: + A new SymbolTable instance. + + See also: `SymbolTable.read`, `SymbolTable.read_fst`. + """ + cdef unique_ptr[fst.SymbolTableTextOptions] opts + opts.reset(new fst.SymbolTableTextOptions(allow_negative_labels)) + cdef fst.SymbolTable *tsyms = fst.SymbolTable.ReadText(tostring(filename), + deref(opts)) + if tsyms == NULL: + raise FstIOError("Read failed: {!r}".format(filename)) + return _init_SymbolTable(tsyms) + + @classmethod + def read_fst(cls, filename, bool input_table): + """ + SymbolTable.read_fst(filename, input_table) + + Reads symbol table from an FST file without loading the corresponding FST. + + This class method creates a new SymbolTable by reading either the input or + output symbol table from an FST file, without loading the corresponding FST. + + Args: + filename: The string location of the input FST file. + input_table: Should the input table be read (True) or the output table + (False)? + + Returns: + A new SymbolTable instance, or None if none can be read. + + Raises: + FstIOError: Read failed. + + See also: `SymbolTable.read`, `SymbolTable.read_text`. + """ + cdef fst.SymbolTable *tsyms = fst.FstReadSymbols(filename, input_table) + if tsyms == NULL: + raise FstIOError("Read failed: {!r}".format(filename)) + return _init_SymbolTable(tsyms) + + +cdef _EncodeMapperSymbolTable _init_EncodeMapperSymbolTable( + fst.SymbolTable *table, shared_ptr[fst.EncodeMapperClass] encoder): + cdef _EncodeMapperSymbolTable result = ( + _EncodeMapperSymbolTable.__new__(_EncodeMapperSymbolTable)) + result._table = table + result._encoder = encoder + return result + + +cdef _FstSymbolTable _init_FstSymbolTable(fst.SymbolTable *table, + shared_ptr[fst.FstClass] ifst): + cdef _FstSymbolTable result = _FstSymbolTable.__new__(_FstSymbolTable) + result._table = table + result._fst = ifst + return result + + +cdef _MutableFstSymbolTable _init_MutableFstSymbolTable(fst.SymbolTable *table, + shared_ptr[fst.MutableFstClass] ifst): + cdef _MutableFstSymbolTable result = ( + _MutableFstSymbolTable.__new__(_MutableFstSymbolTable)) + result._table = table + result._mfst = ifst + return result + + +cdef SymbolTable _init_SymbolTable(fst.SymbolTable *table): + cdef SymbolTable result = SymbolTable.__new__(SymbolTable) + result._table = table + return result + + +# Constructive SymbolTable operations. + + +cpdef SymbolTable compact_symbol_table(_SymbolTable syms): + """ + compact_symbol_table(syms) + + Constructively relabels a SymbolTable to make it a contiguous mapping. + + Args: + syms: Input SymbolTable. + + Returns: + A new compacted SymbolTable. + """ + return _init_SymbolTable(fst.CompactSymbolTable(deref(syms._table))) + + +cpdef SymbolTable merge_symbol_table(_SymbolTable lhs, _SymbolTable rhs): + """ + merge_symbol_table(lhs, rhs) + + Merges all symbols from the left table into the right. + + This function creates a new SymbolTable which is the merger of the two input + symbol Tables. Symbols in the right-hand table that conflict with those in the + left-hand table will be assigned values from the left-hand table. Thus the + returned table will never modify symbol assignments from the left-hand side, + but may do so on the right. + + If the left-hand table is associated with an FST, it may be necessary to + relabel it using the output table. + + Args: + lhs: Left-hand side SymbolTable. + rhs: Left-hand side SymbolTable. + + Returns: + A new merged SymbolTable. + + See also: `relabel_symbols`. + """ + return _init_SymbolTable(fst.MergeSymbolTable(deref(lhs._table), + deref(rhs._table), NULL)) + + +## SymbolTableIterator. + + +cdef class SymbolTableIterator(object): + + """ + SymbolTableIterator(syms) + + This class is used for iterating over a symbol table. + """ + + def __repr__(self): + return "".format(id(self)) + + def __init__(self, _SymbolTable syms): + self._siter.reset(new fst.SymbolTableIterator(deref(syms._table))) + + # This just registers this class as a possible iterator. + def __iter__(self): + return self + + # Magic method used to get a Pythonic API out of the C++ API. + def __next__(self): + if self.done(): + raise StopIteration + cdef int64 value = self.value() + cdef string symbol = self.symbol() + self.next() + return (value, symbol) + + cpdef bool done(self): + """ + done(self) + + Indicates whether the iterator is exhausted or not. + + Returns: + True if the iterator is exhausted, False otherwise. + """ + return self._siter.get().Done() + + cpdef void next(self): + """ + next(self) + + Advances the iterator. + """ + self._siter.get().Next() + + cpdef void reset(self): + """ + reset(self) + + Resets the iterator to the initial position. + """ + self._siter.get().Reset() + + cpdef string symbol(self): + """ + symbol(self) + + Returns the current symbol string. + + This method returns the current symbol string at this point in the table. + + Returns: + A symbol string. + """ + return self._siter.get().Symbol() + + cpdef int64 value(self): + """ + value(self) + + Returns the current integer index of the symbol. + + Returns: + An integer index. + """ + return self._siter.get().Value() + + +## EncodeMapper. + + +cdef class EncodeMapper(object): + + """ + EncodeMapper(arc_type="standard", encode_labels=False, encode_weights=False) + + Arc encoder class, wrapping EncodeMapperClass. + + This class provides an object which can be used to encode or decode FST arcs. + This is most useful to convert an FST to an unweighted acceptor, on which + some FST operations are more efficient, and then decoding the FST afterwards. + + To use an instance of this class to encode or decode a mutable FST, pass it + as the first argument to the FST instance methods `encode` and `decode`. + + For implementational reasons, it is not currently possible to use an encoder + on disk to construct this class. + + Args: + arc_type: A string indicating the arc type. + encode_labels: Should labels be encoded? + encode_weights: Should weights be encoded? + """ + + def __repr__(self): + return "".format(id(self)) + + def __init__(self, + arc_type=b"standard", + bool encode_labels=False, + bool encode_weights=False): + cdef uint32 flags = fst.GetEncodeFlags(encode_labels, encode_weights) + self._encoder.reset(new fst.EncodeMapperClass(tostring(arc_type), flags, + fst.ENCODE)) + if not self._encoder: + raise FstOpError("Unknown arc type: {!r}".format(arc_type)) + + cpdef string arc_type(self): + """ + arc_type(self) + + Returns a string indicating the arc type. + """ + return self._encoder.get().ArcType() + + # Python's equivalent to operator(). + + def __call__(self, Arc arc): + """ + self(state, ilabel, olabel, weight, nextstate) + + Uses the encoder to encode an arc. + + Args: + ilabel: The integer index of the input label. + olabel: The integer index of the output label. + weight: A Weight or weight string indicating the desired final weight; if + null, it is set to semiring One. + nextstate: The integer index of the destination state. + + Raises: + FstOpError: Incompatible or invalid weight. + """ + return _init_Arc(self._encoder.get().__call__(deref(arc._arc))) + + cpdef uint32 flags(self): + """ + flags(self) + + Returns the encoder's flags. + """ + return self._encoder.get().Flags() + + cpdef _EncodeMapperSymbolTable input_symbols(self): + """ + input_symbols(self) + + Returns the encoder's input symbol table, or None if none is present. + """ + cdef fst.SymbolTable *syms = const_cast[SymbolTable_ptr]( + self._encoder.get().InputSymbols()) + if syms == NULL: + return + return _init_EncodeMapperSymbolTable(syms, self._encoder) + + cpdef _EncodeMapperSymbolTable output_symbols(self): + """ + output_symbols(self) + + Returns the encoder's output symbol table, or None if none is present. + """ + cdef fst.SymbolTable *syms = const_cast[SymbolTable_ptr]( + self._encoder.get().OutputSymbols()) + if syms == NULL: + return + return _init_EncodeMapperSymbolTable(syms, self._encoder) + + cpdef uint64 properties(self, uint64 mask): + """ + properties(self, mask) + + Provides property bits. + + This method provides user access to the properties of the encoder. + + Args: + mask: The property mask to be compared to the encoder's properties. + + Returns: + A 64-bit bitmask representing the requested properties. + """ + return self._encoder.get().Properties(mask) + + cpdef void set_input_symbols(self, _SymbolTable syms) except *: + """ + set_input_symbols(self, syms) + + Sets the encoder's input symbol table. + + Args: + syms: A SymbolTable. + + See also: `set_output_symbols`. + """ + self._encoder.get().SetInputSymbols(syms._table) + + cpdef void set_output_symbols(self, _SymbolTable syms) except *: + """ + set_output_symbols(self, syms) + + Sets the encoder's output symbol table. + + Args: + syms: A SymbolTable. + + See also: `set_input_symbols`. + """ + self._encoder.get().SetOutputSymbols(syms._table) + + cpdef string weight_type(self): + """ + weight_type(self) + + Returns a string indicating the weight type. + """ + return self._encoder.get().WeightType() + + +## _Fst, _MutableFst, Fst, and helpers. +# +# Fst hierarchy: +# +# _Fst: base class; has-a FstClass*. +# _MutableFst(_Fst): adds mutable methods. +# Fst(filename): pseudo-constructor. + + +cdef class _Fst(object): + + """ + (No constructor.) + + Immutable FST class, wrapping FstClass. + + This class is the basic user-facing FST object. It does not itself support any + mutation operations. + """ + + # IPython notebook magic to produce an SVG of the FST. + def _repr_svg_(self): + """IPython notebook magic to produce an SVG of the FST using GraphViz. + + This method produces an SVG of the internal graph. Users wishing to create + publication-quality graphs should instead use the method `draw`, which + exposes additional parameters. + + Raises: + OSError: Cannot locate the `dot` executable. + subprocess.CalledProcessError: `dot` returned non-zero exit code. + + See also: `draw`, `text`. + """ + # Throws OSError if the dot executable is not found. + proc = subprocess.Popen(["dot", "-Tsvg"], stdin=subprocess.PIPE, + stdout=subprocess.PIPE, stderr=subprocess.PIPE) + cdef stringstream sstrm + fst.DrawFst(deref(self._fst), self._fst.get().InputSymbols(), + self._fst.get().OutputSymbols(), NULL, + self._fst.get().Properties(fst.kAcceptor, True) == + fst.kAcceptor, + b"", 8.5, 11, True, False, 0.4, 0.25, 14, 5, b"g", False, + addr(sstrm), b"_repr_svg") + (sout, serr) = proc.communicate(sstrm.str()) + if proc.returncode != 0: # Just to be explicit. + raise subprocess.CalledProcessError(proc.returncode, self._DOT_TSVG) + return sout.decode("utf8") + + def __repr__(self): + return "<{} Fst at 0x{:x}>".format(self.fst_type(), id(self)) + + def __init__(self): + raise FstDeletedConstructorError( + "Cannot construct {}".format(self.__class__.__name__)) + + def __str__(self): + return self.text() + + # Registers the class for pickling; must be repeated in any subclass which + # can't be derived by _init_XFst. + + def __reduce__(self): + return (_read_from_string, (self.write_to_string(),)) + + cpdef string arc_type(self): + """ + arc_type(self) + + Returns a string indicating the arc type. + """ + return self._fst.get().ArcType() + + cpdef ArcIterator arcs(self, int64 state): + """ + arcs(self, state) + + Returns an iterator over arcs leaving the specified state. + + Args: + state: The source state ID. + + Returns: + An ArcIterator. + + See also: `mutable_arcs`, `states`. + """ + return ArcIterator(self, state) + + cpdef _Fst copy(self): + """ + copy(self) + + Makes a copy of the FST. + """ + return _init_XFst(new fst.FstClass(deref(self._fst))) + + cpdef void draw(self, + filename, + _SymbolTable isymbols=None, + _SymbolTable osymbols=None, + SymbolTable ssymbols=None, + bool acceptor=False, + title=b"", + double width=8.5, + double height=11, + bool portrait=False, + bool vertical=False, + double ranksep=0.4, + double nodesep=0.25, + int32 fontsize=14, + int32 precision=5, + float_format=b"g", + bool show_weight_one=False): + """ + draw(self, filename, isymbols=None, osymbols=None, ssymbols=None, + acceptor=False, title="", width=8.5, height=11, portrait=False, + vertical=False, ranksep=0.4, nodesep=0.25, fontsize=14, + precision=5, float_format="g", show_weight_one=False): + + Writes out the FST in Graphviz text format. + + This method writes out the FST in the dot graph description language. The + graph can be rendered using the `dot` executable provided by Graphviz. + + Args: + filename: The string location of the output dot/Graphviz file. + isymbols: An optional symbol table used to label input symbols. + osymbols: An optional symbol table used to label output symbols. + ssymbols: An optional symbol table used to label states. + acceptor: Should the figure be rendered in acceptor format if possible? + title: An optional string indicating the figure title. + width: The figure width, in inches. + height: The figure height, in inches. + portrait: Should the figure be rendered in portrait rather than + landscape? + vertical: Should the figure be rendered bottom-to-top rather than + left-to-right? + ranksep: The minimum separation separation between ranks, in inches. + nodesep: The minimum separation between nodes, in inches. + fontsize: Font size, in points. + precision: Numeric precision for floats, in number of chars. + float_format: One of: 'e', 'f' or 'g'. + show_weight_one: Should weights equivalent to semiring One be printed? + + See also: `text`. + """ + cdef string filename_string = tostring(filename) + cdef unique_ptr[ofstream] ostrm + ostrm.reset(new ofstream(filename_string)) + cdef fst.SymbolTable *ssymbols_ptr = NULL + if ssymbols is not None: + ssymbols_ptr = ssymbols._table + fst.DrawFst(deref(self._fst), + self._fst.get().InputSymbols() if isymbols is None + else isymbols._table, + self._fst.get().OutputSymbols() if osymbols is None + else osymbols._table, + ssymbols_ptr, acceptor, tostring(title), width, height, portrait, + vertical, ranksep, nodesep, fontsize, precision, + tostring(float_format), show_weight_one, ostrm.get(), + filename_string) + + cpdef Weight final(self, int64 state): + """ + final(self, state) + + Returns the final weight of a state. + + Args: + state: The integer index of a state. + + Returns: + The final Weight of that state. + + Raises: + FstIndexError: State index out of range. + """ + cdef Weight weight = Weight.__new__(Weight) + weight._weight.reset(new fst.WeightClass(self._fst.get().Final(state))) + return weight + + cpdef string fst_type(self): + """ + fst_type(self) + + Returns a string indicating the FST type. + """ + return self._fst.get().FstType() + + cpdef _FstSymbolTable input_symbols(self): + """ + input_symbols(self) + + Returns the FST's input symbol table, or None if none is present. + + See also: `input_symbols`. + """ + cdef fst.SymbolTable *syms = const_cast[SymbolTable_ptr]( + self._fst.get().InputSymbols()) + if syms == NULL: + return + return _init_FstSymbolTable(syms, self._fst) + + cpdef size_t num_arcs(self, int64 state) except *: + """ + num_arcs(self, state) + + Returns the number of arcs leaving a state. + + Args: + state: The integer index of a state. + + Returns: + The number of arcs leaving that state. + + Raises: + FstIndexError: State index out of range. + + See also: `num_states`. + """ + cdef size_t result = self._fst.get().NumArcs(state) + if result == SIZE_MAX: + raise FstIndexError("State index out of range") + return result + + cpdef size_t num_input_epsilons(self, int64 state) except *: + """ + num_input_epsilons(self, state) + + Returns the number of arcs with epsilon input labels leaving a state. + + Args: + state: The integer index of a state. + + Returns: + The number of epsilon-input-labeled arcs leaving that state. + + Raises: + FstIndexError: State index out of range. + + See also: `num_output_epsilons`. + """ + cdef size_t result = self._fst.get().NumInputEpsilons(state) + if result == SIZE_MAX: + raise FstIndexError("State index out of range") + return result + + cpdef size_t num_output_epsilons(self, int64 state) except *: + """ + num_output_epsilons(self, state) + + Returns the number of arcs with epsilon output labels leaving a state. + + Args: + state: The integer index of a state. + + Returns: + The number of epsilon-output-labeled arcs leaving that state. + + Raises: + FstIndexError: State index out of range. + + See also: `num_input_epsilons`. + """ + cdef size_t result = self._fst.get().NumOutputEpsilons(state) + if result == SIZE_MAX: + raise FstIndexError("State index out of range") + return result + + cpdef _FstSymbolTable output_symbols(self): + """ + output_symbols(self) + + Returns the FST's output symbol table, or None if none is present. + + See also: `input_symbols`. + """ + cdef fst.SymbolTable *syms = const_cast[SymbolTable_ptr]( + self._fst.get().OutputSymbols()) + if syms == NULL: + return + return _init_FstSymbolTable(syms, self._fst) + + cpdef uint64 properties(self, uint64 mask, bool test): + """ + properties(self, mask, test) + + Provides property bits. + + This method provides user access to the properties attributes for the FST. + The resulting value is a long integer, but when it is cast to a boolean, + it represents whether or not the FST has the `mask` property. + + Args: + mask: The property mask to be compared to the FST's properties. + test: Should any unknown values be computed before comparing against + the mask? + + Returns: + A 64-bit bitmask representing the requested properties. + """ + return self._fst.get().Properties(mask, test) + + cpdef int64 start(self): + """ + start(self) + + Returns the start state. + """ + return self._fst.get().Start() + + cpdef StateIterator states(self): + """ + states(self) + + Returns an iterator over all states in the FST. + + Returns: + A StateIterator object for the FST. + + See also: `arcs`, `mutable_arcs`. + """ + return StateIterator(self) + + cpdef string text(self, _SymbolTable isymbols=None, + _SymbolTable osymbols=None, _SymbolTable ssymbols=None, + bool acceptor=False, bool show_weight_one=False, missing_sym=b""): + """ + text(self, isymbols=None, osymbols=None, ssymbols=None, acceptor=False, + show_weight_one=False, missing_sym="") + + Produces a human-readable string representation of the FST. + + This method generates a human-readable string representation of the FST. + The caller may optionally specify SymbolTables used to label input labels, + output labels, or state labels, respectively. + + Args: + isymbols: An optional symbol table used to label input symbols. + osymbols: An optional symbol table used to label output symbols. + ssymbols: An optional symbol table used to label states. + acceptor: Should the FST be rendered in acceptor format if possible? + show_weight_one: Should weights equivalent to semiring One be printed? + missing_symbol: The string to be printed when symbol table lookup fails. + + Returns: + A formatted string representing the machine. + """ + # Prints FST to stringstream, then returns resulting string. + cdef fst.SymbolTable *ssymbols_ptr = NULL + if ssymbols is not None: + ssymbols_ptr = ssymbols._table + cdef stringstream sstrm + fst.PrintFst(deref(self._fst), sstrm, b"", + self._fst.get().InputSymbols() if isymbols is None + else isymbols._table, + self._fst.get().OutputSymbols() if osymbols is None + else osymbols._table, + ssymbols_ptr, acceptor, show_weight_one, tostring(missing_sym)) + return sstrm.str() + + cpdef bool verify(self): + """ + verify(self) + + Verifies that an FST's contents are sane. + + Returns: + True if the contents are sane, False otherwise. + """ + return fst.Verify(deref(self._fst)) + + cpdef string weight_type(self): + """ + weight_type(self) + + Provides the FST's weight type. + + Returns: + A string representing the weight type. + """ + return self._fst.get().WeightType() + + cpdef void write(self, filename) except *: + """ + write(self, filename) + + Serializes FST to a file. + + This method writes the FST to a file in a binary format. + + Args: + filename: The string location of the output file. + + Raises: + FstIOError: Write failed. + """ + if not self._fst.get().Write(tostring(filename)): + raise FstIOError("Write failed: {!r}".format(filename)) + + cpdef string write_to_string(self): + """ + write_to_string(self) + + Serializes FST to a string. + + Returns: + A string. + + Raises: + FstIOError: Write to string failed. + + See also: `read_from_string`. + """ + cdef stringstream sstrm + if not self._fst.get().Write(sstrm, "write_to_string"): + raise FstIOError("Write to string failed") + return sstrm.str() + + +cdef class _MutableFst(_Fst): + + """ + (No constructor.) + + Mutable FST class, wrapping MutableFstClass. + + This class extends _Fst by adding mutation operations. + """ + + cdef void _check_mutating_imethod(self) except *: + """Checks whether an operation mutating the FST has produced an error. + + This function is not visible to Python users. + """ + if self._fst.get().Properties(fst.kError, True) == fst.kError: + raise FstOpError("Operation failed") + + cdef void _add_arc(self, int64 state, Arc arc) except *: + if not self._fst.get().ValidStateId(state): + raise FstIndexError("State index out of range") + if not self._mfst.get().AddArc(state, deref(arc._arc)): + raise FstOpError("Incompatible or invalid weight type") + self._check_mutating_imethod() + + def add_arc(self, int64 state, Arc arc): + """ + add_arc(self, state, arc) + + Adds a new arc to the FST and return self. + + Args: + state: The integer index of the source state. + arc: The arc to add. + + Returns: + self. + + Raises: + FstIndexError: State index out of range. + FstOpdexError: Incompatible or invalid weight type. + + See also: `add_state`. + """ + self._add_arc(state, arc) + return self + + cpdef int64 add_state(self) except *: + """ + add_state(self) + + Adds a new state to the FST and returns the state ID. + + Returns: + The integer index of the new state. + + See also: `add_arc`, `set_start`, `set_final`. + """ + cdef int64 result = self._mfst.get().AddState() + self._check_mutating_imethod() + return result + + cdef void _arcsort(self, sort_type=b"ilabel") except *: + cdef fst.ArcSortType sort_type_enum + if not fst.GetArcSortType(tostring(sort_type), addr(sort_type_enum)): + raise FstArgError("Unknown sort type {!r}".format(sort_type)) + fst.ArcSort(self._mfst.get(), sort_type_enum) + self._check_mutating_imethod() + + def arcsort(self, sort_type=b"ilabel"): + """ + arcsort(self, sort_type="ilabel") + + Sorts arcs leaving each state of the FST. + + This operation destructively sorts arcs leaving each state using either + input or output labels. + + Args: + sort_type: Either "ilabel" (sort arcs according to input labels) or + "olabel" (sort arcs according to output labels). + + Returns: + self. + + Raises: + FstArgError: Unknown sort type. + + See also: `topsort`. + """ + self._arcsort(sort_type) + return self + + cdef void _closure(self, bool closure_plus=False) except *: + fst.Closure(self._mfst.get(), fst.GetClosureType(closure_plus)) + self._check_mutating_imethod() + + def closure(self, bool closure_plus=False): + """ + closure(self, closure_plus=False) + + Computes concatenative closure. + + This operation destructively converts the FST to its concatenative closure. + If A transduces string x to y with weight a, then the closure transduces x + to y with weight a, xx to yy with weight a \otimes a, xxx to yyy with weight + a \otimes a \otimes a, and so on. The empty string is also transduced to + itself with semiring One if `closure_plus` is False. + + Args: + closure_plus: If False, do not accept the empty string. + + Returns: + self. + """ + self._closure(closure_plus) + return self + + cdef void _concat(self, _Fst ifst) except *: + fst.Concat(self._mfst.get(), deref(ifst._fst)) + self._check_mutating_imethod() + + def concat(self, _Fst ifst): + """ + concat(self, ifst) + + Computes the concatenation (product) of two FSTs. + + This operation destructively concatenates the FST with a second FST. If A + transduces string x to y with weight a and B transduces string w to v with + weight b, then their concatenation transduces string xw to yv with weight a + \otimes b. + + Args: + ifst: The second input FST. + + Returns: + self. + """ + self._concat(ifst) + return self + + cdef void _connect(self) except *: + fst.Connect(self._mfst.get()) + self._check_mutating_imethod() + + def connect(self): + """ + connect(self) + + Removes unsuccessful paths. + + This operation destructively trims the FST, removing states and arcs that + are not part of any successful path. + + Returns: + self. + """ + self._connect() + return self + + cdef void _decode(self, EncodeMapper encoder) except *: + fst.Decode(self._mfst.get(), deref(encoder._encoder)) + self._check_mutating_imethod() + + def decode(self, EncodeMapper encoder): + """ + decode(self, encoder) + + Decodes encoded labels and/or weights. + + This operation reverses the encoding performed by `encode`. + + Args: + encoder: An EncodeMapper object used to encode the FST. + + Returns: + self. + + See also: `encode`. + """ + self._decode(encoder) + return self + + cdef void _delete_arcs(self, int64 state, size_t n=0) except *: + if not (self._mfst.get().DeleteArcs(state, n) if n else + self._mfst.get().DeleteArcs(state)): + raise FstIndexError("State index out of range") + self._check_mutating_imethod() + + def delete_arcs(self, int64 state, size_t n=0): + """ + delete_arcs(self, state, n=0) + + Deletes arcs leaving a particular state. + + Args: + state: The integer index of a state. + n: An optional argument indicating how many arcs to be deleted. If this + argument is omitted or passed as zero, all arcs from this state are + deleted. + + Returns: + self. + + Raises: + FstIndexError: State index out of range. + + See also: `delete_states`. + """ + self._delete_arcs(state, n) + return self + + cdef void _delete_states(self, states=None) except *: + # Only the former signature has a possible indexing failure. + if states: + if not self._mfst.get().DeleteStates( states): + raise FstIndexError("State index out of range") + else: + self._mfst.get().DeleteStates() + self._check_mutating_imethod() + + def delete_states(self, states=None): + """ + delete_states(self, states=None) + + Deletes states. + + Args: + states: An optional iterable of integer indices of the states to be + deleted. If this argument is omitted, all states are deleted. + + Returns: + self. + + Raises: + FstIndexError: State index out of range. + + See also: `delete_arcs`. + """ + self._delete_states(states) + return self + + cdef void _encode(self, EncodeMapper encoder) except *: + fst.Encode(self._mfst.get(), encoder._encoder.get()) + self._check_mutating_imethod() + + def encode(self, EncodeMapper encoder): + """ + encode(self, encoder) + + Encodes labels and/or weights. + + This operation allows for the representation of a weighted transducer as a + weighted acceptor, an unweighted transducer, or an unweighted acceptor by + considering the pair (input label, output label), the pair (input label, + weight), or the triple (input label, output label, weight) as a single + label. Applying this operation mutates the EncodeMapper argument, which + can then be used to decode. + + Args: + encoder: An EncodeMapper object to be used as the encoder. + + Returns: + self. + + See also: `decode`. + """ + self._encode(encoder) + return self + + cdef void _invert(self) except *: + fst.Invert(self._mfst.get()) + self._check_mutating_imethod() + + def invert(self): + """ + invert(self) + + Inverts the FST's transduction. + + This operation destructively inverts the FST's transduction by exchanging + input and output labels. + + Returns: + self. + """ + self._invert() + return self + + cdef void _minimize(self, float delta=fst.kShortestDelta, + bool allow_nondet=False) except *: + # This runs in-place when the second argument is null. + fst.Minimize(self._mfst.get(), NULL, delta, allow_nondet) + self._check_mutating_imethod() + + def minimize(self, float delta=fst.kShortestDelta, bool allow_nondet=False): + """ + minimize(self, delta=1e-6, allow_nondet=False) + + Minimizes the FST. + + This operation destructively performs the minimization of deterministic + weighted automata and transducers. If the input FST A is an acceptor, this + operation produces the minimal acceptor B equivalent to A, i.e. the + acceptor with a minimal number of states that is equivalent to A. If the + input FST A is a transducer, this operation internally builds an equivalent + transducer with a minimal number of states. However, this minimality is + obtained by allowing transition having strings of symbols as output labels, + this known in the litterature as a real-time transducer. Such transducers + are not directly supported by the library. This function will convert such + transducer by expanding each string-labeled transition into a sequence of + transitions. This will results in the creation of new states, hence losing + the minimality property. + + Args: + delta: Comparison/quantization delta. + allow_nondet: Attempt minimization of non-deterministic FST? + + Returns: + self. + """ + self._minimize(delta, allow_nondet) + return self + + cpdef MutableArcIterator mutable_arcs(self, int64 state): + """ + mutable_arcs(self, state) + + Returns a mutable iterator over arcs leaving the specified state. + + Args: + state: The source state ID. + + Returns: + A MutableArcIterator. + + See also: `arcs`, `states`. + """ + return MutableArcIterator(self, state) + + def mutable_input_symbols(self): + """ + mutable_input_symbols(self) + + Returns the FST's (mutable) input symbol table, or None if none is present. + """ + cdef fst.SymbolTable *tst = self._mfst.get().MutableInputSymbols() + if tst == NULL: + return + return _init_MutableFstSymbolTable(tst, self._mfst) + + def mutable_output_symbols(self): + """ + mutable_output_symbols(self) + + Returns the FST's (mutable) output symbol table, or None if none is present. + """ + cdef fst.SymbolTable *tst = self._mfst.get().MutableOutputSymbols() + if tst == NULL: + return + return _init_MutableFstSymbolTable(tst, self._mfst) + + cpdef int64 num_states(self): + """ + num_states(self) + + Returns the number of states. + """ + return self._mfst.get().NumStates() + + cdef void _project(self, bool project_output=False) except *: + fst.Project(self._mfst.get(), fst.GetProjectType(project_output)) + self._check_mutating_imethod() + + def project(self, bool project_output=False): + """ + project(self, project_output=False) + + Converts the FST to an acceptor using input or output labels. + + This operation destructively projects an FST onto its domain or range by + either copying each arc's input label to its output label (the default) or + vice versa. + + Args: + project_output: Should the output labels be projected? + + Returns: + self. + + See also: `decode`, `encode`, `relabel_pairs`, `relabel_symbols`. + """ + self._project(project_output) + return self + + cdef void _prune(self, float delta=fst.kDelta, int64 nstate=fst.kNoStateId, + weight=None) except *: + # Threshold is set to semiring Zero (no pruning) if no weight is specified. + cdef fst.WeightClass wc = _get_WeightClass_or_Zero(self.weight_type(), + weight) + fst.Prune(self._mfst.get(), wc, nstate, delta) + self._check_mutating_imethod() + + def prune(self, + float delta=fst.kDelta, + int64 nstate=fst.kNoStateId, + weight=None): + """ + prune(self, delta=0.0009765625, nstate=NO_STATE_ID, weight=None) + + Removes paths with weights below a certain threshold. + + This operation deletes states and arcs in the input FST that do not belong + to a successful path whose weight is no more (w.r.t the natural semiring + order) than the threshold t \otimes-times the weight of the shortest path in + the input FST. Weights must be commutative and have the path property. + + Args: + delta: Comparison/quantization delta. + nstate: State number threshold. + weight: A Weight or weight string indicating the desired weight threshold + below which paths are pruned; if omitted, no paths are pruned. + + Returns: + self. + + See also: The constructive variant. + """ + self._prune(delta, nstate, weight) + return self + + cdef void _push(self, + float delta=fst.kDelta, + bool remove_total_weight=False, + bool to_final=False) except *: + fst.Push(self._mfst.get(), fst.GetReweightType(to_final), delta, + remove_total_weight) + self._check_mutating_imethod() + + def push(self, + float delta=fst.kDelta, + bool remove_total_weight=False, + bool to_final=False): + """ + push(self, delta=0.0009765625, remove_total_weight=False, to_final=False) + + Pushes weights towards the initial or final states. + + This operation destructively produces an equivalent transducer by pushing + the weights towards the initial state or toward the final states. When + pushing weights towards the initial state, the sum of the weight of the + outgoing transitions and final weight at any non-initial state is equal to + one in the resulting machine. When pushing weights towards the final states, + the sum of the weight of the incoming transitions at any state is equal to + one. Weights need to be left distributive when pushing towards the initial + state and right distributive when pushing towards the final states. + + Args: + delta: Comparison/quantization delta. + remove_total_weight: If pushing weights, should the total weight be + removed? + to_final: Push towards final states? + + Returns: + self. + + See also: The constructive variant, which also supports label pushing. + """ + self._push(delta, remove_total_weight, to_final) + return self + + cdef void _relabel_pairs(self, ipairs=None, opairs=None) except *: + cdef unique_ptr[vector[fst.LabelPair]] _ipairs + _ipairs.reset(new vector[fst.LabelPair]()) + cdef unique_ptr[vector[fst.LabelPair]] _opairs + _opairs.reset(new vector[fst.LabelPair]()) + cdef int64 before + cdef int64 after + if ipairs: + for (before, after) in ipairs: + _ipairs.get().push_back(fst.LabelPair(before, after)) + if opairs: + for (before, after) in opairs: + _opairs.get().push_back(fst.LabelPair(before, after)) + if _ipairs.get().empty() and _opairs.get().empty(): + raise FstArgError("No relabeling pairs specified.") + fst.Relabel(self._mfst.get(), deref(_ipairs), deref(_opairs)) + self._check_mutating_imethod() + + def relabel_pairs(self, ipairs=None, opairs=None): + """ + relabel_pairs(self, ipairs=None, opairs=None) + + Replaces input and/or output labels using pairs of labels. + + This operation destructively relabels the input and/or output labels of the + FST using pairs of the form (old_ID, new_ID); omitted indices are + identity-mapped. + + Args: + ipairs: An iterable containing (older index, newer index) integer pairs. + opairs: An iterable containing (older index, newer index) integer pairs. + + Returns: + self. + + Raises: + FstArgError: No relabeling pairs specified. + + See also: `decode`, `encode`, `project`, `relabel_tables`. + """ + self._relabel_pairs(ipairs, opairs) + return self + + cdef void _relabel_tables(self, + _SymbolTable old_isymbols=None, + _SymbolTable new_isymbols=None, + unknown_isymbol=b"", + bool attach_new_isymbols=True, + _SymbolTable old_osymbols=None, + _SymbolTable new_osymbols=None, + unknown_osymbol=b"", + bool attach_new_osymbols=True) except *: + if new_isymbols is None and new_osymbols is None: + raise FstArgError("No new SymbolTables specified") + cdef fst.SymbolTable *new_isymbols_ptr = NULL + if new_isymbols is not None: + new_isymbols_ptr = new_isymbols._table + cdef fst.SymbolTable *new_osymbols_ptr = NULL + if new_osymbols is not None: + new_osymbols_ptr = new_osymbols._table + fst.Relabel(self._mfst.get(), + self._fst.get().InputSymbols() if old_isymbols is None else + old_isymbols._table, new_isymbols_ptr, tostring(unknown_isymbol), + attach_new_isymbols, + self._fst.get().OutputSymbols() if old_osymbols is None else + old_osymbols._table, new_osymbols_ptr, tostring(unknown_osymbol), + attach_new_osymbols) + self._check_mutating_imethod() + + def relabel_tables(self, + _SymbolTable old_isymbols=None, + _SymbolTable new_isymbols=None, + unknown_isymbol=b"", + bool attach_new_isymbols=True, + _SymbolTable old_osymbols=None, + _SymbolTable new_osymbols=None, + unknown_osymbol=b"", + bool attach_new_osymbols=True): + """ + relabel_tables(self, old_isymbols=None, new_isymbols=None, + unknown_isymbol="", attach_new_isymbols=True, + old_osymbols=None, new_osymbols=None, + unknown_osymbol="", attach_new_osymbols=True) + + Replaces input and/or output labels using SymbolTables. + + This operation destructively relabels the input and/or output labels of the + FST using user-specified symbol tables; omitted symbols are identity-mapped. + + Args: + old_isymbols: The old SymbolTable for input labels, defaulting to the + FST's input symbol table. + new_isymbols: A SymbolTable used to relabel the input labels + unknown_isymbol: Input symbol to use to relabel OOVs (if empty, + OOVs raise an exception) + attach_new_isymbols: Should new_isymbols be made the FST's input symbol + table? + old_osymbols: The old SymbolTable for output labels, defaulting to the + FST's output symbol table. + new_osymbols: A SymbolTable used to relabel the output labels. + unknown_osymbol: Outnput symbol to use to relabel OOVs (if empty, + OOVs raise an exception) + attach_new_isymbols: Should new_osymbols be made the FST's output symbol + table? + + Returns: + self. + + Raises: + FstArgError: No SymbolTable specified. + + See also: `decode`, `encode`, `project`, `relabel_pairs`. + """ + self._relabel_tables(old_isymbols, new_isymbols, + unknown_isymbol, attach_new_isymbols, + old_osymbols, new_osymbols, + unknown_osymbol, attach_new_osymbols) + return self + + cdef void _reserve_arcs(self, int64 state, size_t n) except *: + if not self._mfst.get().ReserveArcs(state, n): + raise FstIndexError("State index out of range") + self._check_mutating_imethod() + + def reserve_arcs(self, int64 state, size_t n): + """ + reserve_arcs(self, state, n) + + Reserve n arcs at a particular state (best effort). + + Args: + state: The integer index of a state. + n: The number of arcs to reserve. + + Returns: + self. + + Raises: + FstIndexError: State index out of range. + + See also: `reserve_states`. + """ + self._reserve_arcs(state, n) + return self + + cdef void _reserve_states(self, int64 n) except *: + self._mfst.get().ReserveStates(n) + self._check_mutating_imethod() + + def reserve_states(self, int64 n): + """ + reserve_states(self, n) + + Reserve n states (best effort). + + Args: + n: The number of states to reserve. + + Returns: + self. + + See also: `reserve_arcs`. + """ + self._reserve_states(n) + return self + + cdef void _reweight(self, potentials, bool to_final=False) except *: + cdef unique_ptr[vector[fst.WeightClass]] _potentials + _potentials.reset(new vector[fst.WeightClass]()) + cdef string weight_type = self.weight_type() + for weight in potentials: + _potentials.get().push_back(_get_WeightClass_or_One(self.weight_type(), + weight)) + fst.Reweight(self._mfst.get(), deref(_potentials), + fst.GetReweightType(to_final)) + self._check_mutating_imethod() + + def reweight(self, potentials, bool to_final=False): + """ + reweight(self, potentials, to_final=False) + + Reweights an FST using an iterable of potentials. + + This operation destructively reweights an FST according to the potentials + and in the direction specified by the user. An arc of weight w, with an + origin state of potential p and destination state of potential q, is + reweighted by p^{-1} \otimes (w \otimes q) when reweighting towards the + initial state, and by (p \otimes w) \otimes q^{-1} when reweighting towards + the final states. The weights must be left distributive when reweighting + towards the initial state and right distributive when reweighting towards + the final states (e.g., TropicalWeight and LogWeight). + + Args: + potentials: An iterable of Weight or weight strings. + to_final: Push towards final states? + + Returns: + self. + """ + self._reweight(potentials, to_final) + return self + + cdef void _rmepsilon(self, + queue_type=b"auto", + bool connect=True, + weight=None, + int64 nstate=fst.kNoStateId, + float delta=fst.kShortestDelta) except *: + cdef fst.WeightClass wc = _get_WeightClass_or_Zero(self.weight_type(), + weight) + cdef unique_ptr[fst.RmEpsilonOptions] opts + opts.reset(new fst.RmEpsilonOptions(_get_queue_type(tostring(queue_type)), + connect, wc, nstate, delta)) + fst.RmEpsilon(self._mfst.get(), deref(opts)) + self._check_mutating_imethod() + + def rmepsilon(self, + queue_type=b"auto", + bool connect=True, + weight=None, + int64 nstate=fst.kNoStateId, + float delta=fst.kShortestDelta): + """ + rmepsilon(self, queue_type="auto", connect=True, weight=None, + nstate=NO_STATE_ID, delta=1e-6): + + Removes epsilon transitions. + + This operation destructively removes epsilon transitions, i.e., those where + both input and output labels are epsilon) from an FST. + + Args: + queue_type: A string matching a known queue type; one of: "auto", "fifo", + "lifo", "shortest", "state", "top". + connect: Should output be trimmed? + weight: A Weight or weight string indicating the desired weight threshold + below which paths are pruned; if omitted, no paths are pruned. + nstate: State number threshold. + delta: Comparison/quantization delta. + + Returns: + self. + """ + self._rmepsilon(queue_type, connect, weight, nstate, delta) + return self + + cdef void _set_final(self, int64 state, weight=None) except *: + if not self._mfst.get().ValidStateId(state): + raise FstIndexError("State index out of range") + cdef fst.WeightClass wc = _get_WeightClass_or_One(self.weight_type(), + weight) + if not self._mfst.get().SetFinal(state, wc): + raise FstOpError("Incompatible or invalid weight") + self._check_mutating_imethod() + + def set_final(self, int64 state, weight=None): + """ + set_final(self, state, weight) + + Sets the final weight for a state. + + Args: + state: The integer index of a state. + weight: A Weight or weight string indicating the desired final weight; if + omitted, it is set to semiring One. + + Returns: + self. + + Raises: + FstIndexError: State index out of range. + FstOpError: Incompatible or invalid weight. + + See also: `set_start`. + """ + self._set_final(state, weight) + return self + + cdef void _set_input_symbols(self, _SymbolTable syms) except *: + if syms is None: + self._mfst.get().SetInputSymbols(NULL) + return + self._mfst.get().SetInputSymbols(syms._table) + self._check_mutating_imethod() + + def set_input_symbols(self, _SymbolTable syms): + """ + set_input_symbols(self, syms) + + Sets the input symbol table. + + Passing None as a value will delete the input symbol table. + + Args: + syms: A SymbolTable. + + Returns: + self. + + See also: `set_output_symbols`. + """ + self._set_input_symbols(syms) + return self + + cdef void _set_output_symbols(self, _SymbolTable syms) except *: + if syms is None: + self._mfst.get().SetOutputSymbols(NULL) + return + self._mfst.get().SetOutputSymbols(syms._table) + self._check_mutating_imethod() + + def set_output_symbols(self, _SymbolTable syms): + """ + set_output_symbols(self, syms) + + Sets the output symbol table. + + Passing None as a value will delete the output symbol table. + + Args: + syms: A SymbolTable. + + Returns: + self. + + See also: `set_input_symbols`. + """ + self._set_output_symbols(syms) + return self + + cdef void _set_properties(self, uint64 props, uint64 mask): + self._mfst.get().SetProperties(props, mask) + + def set_properties(self, uint64 props, uint64 mask): + """ + set_properties(self, props, mask) + + Sets the properties bits. + + Args: + props: The properties to be set. + mask: A mask to be applied to the `props` argument before setting the + FST's properties. + + Returns: + self. + """ + self._set_properties(props, mask) + return self + + cdef void _set_start(self, int64 state) except *: + if not self._mfst.get().SetStart(state): + raise FstIndexError("State index out of range") + self._check_mutating_imethod() + + def set_start(self, int64 state): + """ + set_start(self, state) + + Sets a state to be the initial state state. + + Args: + state: The integer index of a state. + + Returns: + self. + + Raises: + FstIndexError: State index out of range. + + See also: `set_final`. + """ + self._set_start(state) + return self + + cdef void _topsort(self) except *: + # TopSort returns False if the FST is cyclic, and thus can't be TopSorted. + if not fst.TopSort(self._mfst.get()): + logging.warning("Cannot topsort cyclic FST.") + self._check_mutating_imethod() + + def topsort(self): + """ + topsort(self) + + Sorts transitions by state IDs. + + This operation destructively topologically sorts the FST, if it is acyclic; + otherwise it remains unchanged. Once sorted, all transitions are from lower + state IDs to higher state IDs + + Returns: + self. + + See also: `arcsort`. + """ + self._topsort() + return self + + cdef void _union(self, _Fst ifst) except *: + fst.Union(self._mfst.get(), deref(ifst._fst)) + self._check_mutating_imethod() + + def union(self, _Fst ifst): + """ + union(self, ifst) + + Computes the union (sum) of two FSTs. + + This operation computes the union (sum) of two FSTs. If A transduces string + x to y with weight a and B transduces string w to v with weight b, then + their union transduces x to y with weight a and w to v with weight b. + + Args: + ifst: The second input FST. + + Returns: + self. + """ + self._union(ifst) + return self + + +# Pseudo-constructors for _Fst and _MutableFst. +# +# _init_Fst and _init_MutableFst use an FstClass pointer to instantiate _Fst +# and _MutableFst objects, respectively. The latter function is only safe to +# call when the FST being wrapped is known to be kMutable. The caller can +# safely use it when they have either checked this bit (e.g., by using +# _init_XFst) or have themselves constructed a mutable container for the +# FstClass pointer they're passing (e.g., most of the constructive operations, +# storing their results in a VectorFstClass, a derivative of MutableFstClass). +# +# _create_Fst constructs an empty VectorFstClass of a user-specified arc type, +# and passes this pointer to _init_MutableFst. +# +# _read_Fst reads an FST from disk, performing FST conversion if requested, and +# then passes this pointer to _init_XFst. +# +# The Python class Fst provides a wrapper for these two operations. The former +# can be accessed by calling Fst(...), which acts like a class method, and the +# latter via Fst.read(...), which acts like a static method. This is a bit +# nasty, but totally hidden from the Python user. + + +cdef _Fst _init_Fst(FstClass_ptr tfst): + if tfst.Properties(fst.kError, True): + raise FstOpError("Operation failed") + cdef _Fst ofst = _Fst.__new__(_Fst) + ofst._fst.reset(tfst) + return ofst + + +cdef _MutableFst _init_MutableFst(MutableFstClass_ptr tfst): + if tfst.Properties(fst.kError, True): + raise FstOpError("Operation failed") + cdef _MutableFst ofst = _MutableFst.__new__(_MutableFst) + ofst._fst.reset(tfst) + # Makes a copy of it as the derived type! Cool. + ofst._mfst = static_pointer_cast[fst.MutableFstClass, fst.FstClass](ofst._fst) + return ofst + + +cdef _Fst _init_XFst(FstClass_ptr tfst): + if tfst.Properties(fst.kMutable, True): + return _init_MutableFst(static_cast[MutableFstClass_ptr](tfst)) + else: + return _init_Fst(tfst) + + +cdef _MutableFst _create_Fst(arc_type=b"standard"): + cdef unique_ptr[fst.VectorFstClass] tfst + tfst.reset(new fst.VectorFstClass(tostring(arc_type))) + if tfst.get() == NULL: + raise FstOpError("Unknown arc type: {!r}".format(arc_type)) + return _init_MutableFst(tfst.release()) + + +cpdef _Fst _read(filename): + cdef unique_ptr[fst.FstClass] tfst + tfst.reset(fst.FstClass.Read(tostring(filename))) + if tfst.get() == NULL: + raise FstIOError("Read failed: {!r}".format(filename)) + return _init_XFst(tfst.release()) + + +cpdef _Fst _read_from_string(state): + cdef stringstream sstrm + sstrm << tostring(state) + cdef unique_ptr[fst.FstClass] tfst + tfst.reset(fst.FstClass.ReadFromStream(sstrm, b"")) + if tfst.get() == NULL: + raise FstIOError("Read failed: ") + return _init_XFst(tfst.release()) + + +class Fst(object): + + """ + Fst(arc_type="standard") + + Constructs an empty FST. + + Args: + arc_type: A string indicating the arc type. + + Raises: + FstError: Unknown arc type. + + Raises: + FstOpError: operation failed. + """ + + def __new__(cls, arc_type=b"standard"): + return _create_Fst(arc_type) + + @staticmethod + def read(filename): + """ + read(filename): + + Reads an FST from a file. + + Args: + filename: The string location of the input file. + + Returns: + An FST object. + + Raises: + FstIOError: Read failed. + """ + return _read(filename) + + @staticmethod + def read_from_string(state): + """ + read_from_string(string, fst_type=None) + + Reads an FST from a serialized string. + + Args: + state: A string containing the serialized FST. + + Returns: + An FST object. + + Raises: + FstIOError: Read failed. + FstOpError: Read-time conversion failed. + + See also: `write_to_string`. + """ + return _read_from_string(state) + + +## FST constants. + + +NO_LABEL = fst.kNoLabel +NO_STATE_ID = fst.kNoStateId +# TODO(kbg): Figure out how to access static class variables so I don't have +# to do it this way. +NO_SYMBOL = kNoSymbol + + +## FST properties. + + +EXPANDED = fst.kExpanded +MUTABLE = fst.kMutable +ERROR = fst.kError +ACCEPTOR = fst.kAcceptor +NOT_ACCEPTOR = fst.kNotAcceptor +I_DETERMINISTIC = fst.kIDeterministic +NON_I_DETERMINISTIC = fst.kNonIDeterministic +O_DETERMINISTIC = fst.kODeterministic +NON_O_DETERMINISTIC = fst.kNonODeterministic +EPSILONS = fst.kEpsilons +NO_EPSILONS = fst.kNoEpsilons +I_EPSILONS = fst.kIEpsilons +NO_I_EPSILONS = fst.kNoIEpsilons +O_EPSILONS = fst.kOEpsilons +NO_O_EPSILONS = fst.kNoOEpsilons +I_LABEL_SORTED = fst.kILabelSorted +NOT_I_LABEL_SORTED = fst.kNotILabelSorted +O_LABEL_SORTED = fst.kOLabelSorted +NOT_O_LABEL_SORTED = fst.kNotOLabelSorted +WEIGHTED = fst.kWeighted +UNWEIGHTED = fst.kUnweighted +CYCLIC = fst.kCyclic +ACYCLIC = fst.kAcyclic +INITIAL_CYCLIC = fst.kInitialCyclic +INITIAL_ACYCLIC = fst.kInitialAcyclic +TOP_SORTED = fst.kTopSorted +NOT_TOP_SORTED = fst.kNotTopSorted +ACCESSIBLE = fst.kAccessible +NOT_ACCESSIBLE = fst.kNotAccessible +COACCESSIBLE = fst.kCoAccessible +NOT_COACCESSIBLE = fst.kNotCoAccessible +STRING = fst.kString +NOT_STRING = fst.kNotString +WEIGHTED_CYCLES = fst.kWeightedCycles +UNWEIGHTED_CYCLES = fst.kUnweightedCycles +NULL_PROPERTIES = fst.kNullProperties +COPY_PROPERTIES = fst.kCopyProperties +INTRINSIC_PROPERTIES = fst.kIntrinsicProperties +EXTRINSIC_PROPERTIES = fst.kExtrinsicProperties +SET_START_PROPERTIES = fst.kSetStartProperties +SET_FINAL_PROPERTIES = fst.kSetFinalProperties +ADD_STATE_PROPERTIES = fst.kAddStateProperties +ADD_ARC_PROPERTIES = fst.kAddArcProperties +SET_ARC_PROPERTIES = fst.kSetArcProperties +DELETE_STATE_PROPERTIES = fst.kDeleteStatesProperties +DELETE_ARC_PROPERTIES = fst.kDeleteArcsProperties +STATE_SORT_PROPERTIES = fst.kStateSortProperties +ARC_SORT_PROPERTIES = fst.kArcSortProperties +I_LABEL_INVARIANT_PROPERTIES = fst.kILabelInvariantProperties +O_LABEL_INVARIANT_PROPERTIES = fst.kOLabelInvariantProperties +WEIGHT_INVARIANT_PROPERTIES = fst.kWeightInvariantProperties +ADD_SUPERFINAL_PROPERTIES = fst.kAddSuperFinalProperties +RM_SUPERFINAL_PROPERTIES = fst.kRmSuperFinalProperties +BINARY_PROPERTIES = fst.kBinaryProperties +TRINARY_PROPERTIES = fst.kTrinaryProperties +POS_TRINARY_PROPERTIES = fst.kPosTrinaryProperties +NEG_TRINARY_PROPERTIES = fst.kNegTrinaryProperties +FST_PROPERTIES = fst.kFstProperties + + +## Arc iterator properties. + + +ARC_I_LABEL_VALUE = fst.kArcILabelValue +ARC_O_LABEL_VALUE = fst.kArcOLabelValue +ARC_WEIGHT_VALUE = fst.kArcWeightValue +ARC_NEXT_STATE_VALUE = fst.kArcNextStateValue +ARC_NO_CACHE = fst.kArcNoCache +ARC_VALUE_FLAGS = fst.kArcValueFlags +ARC_FLAGS = fst.kArcFlags + + +## EncodeMapper properties. + + +ENCODE_LABELS = fst.kEncodeLabels +ENCODE_WEIGHTS = fst.kEncodeWeights +ENCODE_FLAGS = fst.kEncodeFlags + + +## Arc, ArcIterator, and MutableArcIterator. + + +cdef class Arc(object): + + """ + Arc(ilabel, olabel, weight, nextstate) + + This class represents an arc while remaining agnostic about the underlying arc + type. Attributes of the arc can be accessed or mutated, and the arc can be + copied. + + Attributes: + ilabel: The input label. + olabel: The output label. + weight: The arc weight. + nextstate: The destination state for the arc. + """ + + def __repr__(self): + return "".format(id(self)) + + def __init__(self, int64 ilabel, int64 olabel, weight, int64 nextstate): + cdef fst.WeightClass wc = _get_WeightClass_or_One(b"tropical", weight) + self._arc.reset(new fst.ArcClass(ilabel, olabel, wc, nextstate)) + + cpdef Arc copy(self): + return Arc(self.ilabel, self.olabel, self.weight, self.nextstate) + + property ilabel: + + def __get__(self): + return deref(self._arc).ilabel + + def __set__(self, int64 value): + deref(self._arc).ilabel = value + + property olabel: + + def __get__(self): + return deref(self._arc).olabel + + def __set__(self, int64 value): + deref(self._arc).olabel = value + + property weight: + + def __get__(self): + cdef Weight weight = Weight.__new__(Weight) + weight._weight.reset(new fst.WeightClass(deref(self._arc).weight)) + return weight + + def __set__(self, weight): + deref(self._arc).weight = _get_WeightClass_or_One(b"tropical", weight) + + property nextstate: + + def __get__(self): + return deref(self._arc).nextstate + + def __set__(self, int64 value): + deref(self._arc).nextstate = value + + +cdef Arc _init_Arc(const fst.ArcClass &arc): + cdef Weight weight = Weight.__new__(Weight) + weight._weight.reset(new fst.WeightClass(arc.weight)) + return Arc(arc.ilabel, arc.olabel, weight, arc.nextstate) + + +cdef class ArcIterator(object): + + """ + ArcIterator(ifst, state) + + This class is used for iterating over the arcs leaving some state of an FST. + """ + + def __repr__(self): + return "".format(id(self)) + + def __init__(self, _Fst ifst, int64 state): + if not ifst._fst.get().ValidStateId(state): + raise FstIndexError("State index out of range") + # Makes copy of the shared_ptr, potentially extending the FST's lifetime. + self._fst = ifst._fst + self._aiter.reset(new fst.ArcIteratorClass(deref(self._fst), state)) + + # This just registers this class as a possible iterator. + def __iter__(self): + return self + + # Magic method used to get a Pythonic API out of the C++ API. + def __next__(self): + if self.done(): + raise StopIteration + result = self.value() + self.next() + return result + + cpdef bool done(self): + """ + done(self) + + Indicates whether the iterator is exhausted or not. + + Returns: + True if the iterator is exhausted, False otherwise. + """ + return self._aiter.get().Done() + + cpdef uint32 flags(self): + """ + flags(self) + + Returns the current iterator behavioral flags. + + Returns: + The current iterator behavioral flags as an integer. + """ + return self._aiter.get().Flags() + + cpdef void next(self): + """ + next(self) + + Advances the iterator. + """ + self._aiter.get().Next() + + cpdef size_t position(self): + """ + position(self) + + Returns the position of the iterator. + + Returns: + The iterator's position, expressed as an integer. + """ + return self._aiter.get().Position() + + cpdef void reset(self): + """ + reset(self) + + Resets the iterator to the initial position. + """ + self._aiter.get().Reset() + + cpdef void seek(self, size_t a): + """ + seek(self, a) + + Advance the iterator to a new position. + + Args: + a: The position to seek to. + """ + self._aiter.get().Seek(a) + + cpdef void set_flags(self, uint32 flags, uint32 mask): + """ + set_flags(self, flags, mask) + + Sets the current iterator behavioral flags. + + Args: + flags: The properties to be set. + mask: A mask to be applied to the `flags` argument before setting them. + """ + self._aiter.get().SetFlags(flags, mask) + + cpdef object value(self): + """ + value(self) + + Returns the current arc. + """ + return _init_Arc(self._aiter.get().Value()) + + +cdef class MutableArcIterator(object): + + """ + MutableArcIterator(ifst, state) + + This class is used for iterating over the arcs leaving some state of an FST, + also permitting mutation of the current arc. + """ + + def __repr__(self): + return "".format(id(self)) + + def __init__(self, _MutableFst ifst, int64 state): + if not ifst._fst.get().ValidStateId(state): + raise FstIndexError("State index out of range") + # Makes copy of the shared_ptr, potentially extending the FST's lifetime. + self._mfst = ifst._mfst + self._aiter.reset(new fst.MutableArcIteratorClass(ifst._mfst.get(), state)) + + cpdef bool done(self): + """ + done(self) + + Indicates whether the iterator is exhausted or not. + + Returns: + True if the iterator is exhausted, False otherwise. + """ + return self._aiter.get().Done() + + cpdef uint32 flags(self): + """ + flags(self) + + Returns the current iterator behavioral flags. + + Returns: + The current iterator behavioral flags as an integer. + """ + return self._aiter.get().Flags() + + cpdef void next(self): + """ + next(self) + + Advances the iterator. + """ + self._aiter.get().Next() + + cpdef size_t position(self): + """ + position(self) + + Returns the position of the iterator. + + Returns: + The iterator's position, expressed as an integer. + """ + return self._aiter.get().Position() + + cpdef void reset(self): + """ + reset(self) + + Resets the iterator to the initial position. + """ + self._aiter.get().Reset() + + cpdef void seek(self, size_t a): + """ + seek(self, a) + + Advance the iterator to a new position. + + Args: + a: The position to seek to. + """ + self._aiter.get().Seek(a) + + cpdef void set_flags(self, uint32 flags, uint32 mask): + """ + set_flags(self, flags, mask) + + Sets the current iterator behavioral flags. + + Args: + flags: The properties to be set. + mask: A mask to be applied to the `flags` argument before setting them. + """ + self._aiter.get().SetFlags(flags, mask) + + cpdef void set_value(self, Arc arc): + """ + set_value(self, arc) + + Replace the current arc with a new arc. + + Args: + arc: The arc to replace the current arc with. + """ + self._aiter.get().SetValue(deref(arc._arc)) + + cpdef object value(self): + """ + value(self) + + Returns the current arc. + """ + return _init_Arc(self._aiter.get().Value()) + + +## StateIterator. + + +cdef class StateIterator(object): + + """ + StateIterator(ifst) + + This class is used for iterating over the states in an FST. + """ + + def __repr__(self): + return "".format(id(self)) + + def __init__(self, _Fst ifst): + # Makes copy of the shared_ptr, potentially extending the FST's lifetime. + self._fst = ifst._fst + self._siter.reset(new fst.StateIteratorClass(deref(self._fst))) + + # This just registers this class as a possible iterator. + def __iter__(self): + return self + + # Magic method used to get a Pythonic API out of the C++ API. + def __next__(self): + if self.done(): + raise StopIteration + cdef int64 result = self.value() + self.next() + return result + + cpdef bool done(self): + """ + done(self) + + Indicates whether the iterator is exhausted or not. + + Returns: + True if the iterator is exhausted, False otherwise. + """ + return self._siter.get().Done() + + cpdef void next(self): + """ + next(self) + + Advances the iterator. + """ + self._siter.get().Next() + + cpdef void reset(self): + """ + reset(self) + + Resets the iterator to the initial position. + """ + self._siter.get().Reset() + + cpdef int64 value(self): + """ + value(self) + + Returns the current state index. + """ + return self._siter.get().Value() + + +## FST operations. + + +cdef _Fst _map(_Fst ifst, + float delta=fst.kDelta, + map_type=b"identity", + double power=1., + weight=None): + cdef fst.MapType map_type_enum + if not fst.GetMapType(tostring(map_type), addr(map_type_enum)): + raise FstArgError("Unknown map type: {!r}".format(map_type)) + cdef fst.WeightClass wc = (_get_WeightClass_or_One(ifst.weight_type(), + weight) if map_type_enum == fst.TIMES_MAPPER else + _get_WeightClass_or_Zero(ifst.weight_type(), weight)) + return _init_XFst(fst.Map(deref(ifst._fst), map_type_enum, delta, power, wc)) + + +cpdef _Fst arcmap(_Fst ifst, + float delta=fst.kDelta, + map_type=b"identity", + double power=1., + weight=None): + """ + arcmap(ifst, delta=0.0009765625, map_type="identity", weight=None) + + Constructively applies a transform to all arcs and final states. + + This operation transforms each arc and final state in the input FST using + one of the following: + + * identity: maps to self. + * input_epsilon: replaces all input labels with epsilon. + * invert: reciprocates all non-Zero weights. + * float_power: raises all weights to a floating-point power. + * output_epsilon: replaces all output labels with epsilon. + * quantize: quantizes weights. + * plus: adds a constant to all weights. + * power: raises all weights to an integral power. + * rmweight: replaces all non-Zero weights with 1. + * superfinal: redirects final states to a new superfinal state. + * times: right-multiplies a constant to all weights. + * to_log: converts weights to the log semiring. + * to_log64: converts weights to the log64 semiring. + * to_standard: converts weights to the tropical ("standard") semiring. + + Args: + ifst: The input FST. + delta: Comparison/quantization delta (ignored unless `map_type` is + `quantize`). + map_type: A string matching a known mapping operation (see above). + power: A positive scalar or integer power; ignored unless `map_type` is + `float_power` or `power` (in which case it defaults to 1). + weight: A Weight or weight string passed to the arc-mapper; ignored unless + `map_type` is `plus` (in which case it defaults to semiring Zero) or + `times` (in which case it defaults to semiring One). + + Returns: + An FST with arcs and final states remapped. + + Raises: + FstArgError: Unknown map type. + + See also: `statemap`. + """ + return _map(ifst, delta, map_type, power, weight) + + +cpdef _MutableFst compose(_Fst ifst1, + _Fst ifst2, + compose_filter=b"auto", + bool connect=True): + """ + compose(ifst1, ifst2, compose_filter="auto", connect=True) + + Constructively composes two FSTs. + + This operation computes the composition of two FSTs. If A transduces string + x to y with weight a and B transduces y to z with weight b, then their + composition transduces string x to z with weight a \otimes b. The output + labels of the first transducer or the input labels of the second transducer + must be sorted (or otherwise support appropriate matchers). + + Args: + ifst1: The first input FST. + ifst2: The second input FST. + compose_filter: A string matching a known composition filter; one of: + "alt_sequence", "auto", "match", "null", "sequence", "trivial". + connect: Should output be trimmed? + + Returns: + An FST. + + See also: `arcsort`. + """ + cdef unique_ptr[fst.VectorFstClass] tfst + tfst.reset(new fst.VectorFstClass(ifst1.arc_type())) + cdef unique_ptr[fst.ComposeOptions] opts + opts.reset(new fst.ComposeOptions(connect, + _get_compose_filter(tostring(compose_filter)))) + fst.Compose(deref(ifst1._fst), deref(ifst2._fst), tfst.get(), deref(opts)) + return _init_MutableFst(tfst.release()) + + +cpdef _Fst convert(_Fst ifst, fst_type=None): + """ + convert(ifst, fst_type=None) + + Constructively converts an FST to a new internal representation. + + Args: + ifst: The input FST. + fst_type: A string indicating the FST type to convert to, or None if + no conversion is desired. + + Returns: + An equivalent Fst converted to the desired FST type. + + Raises: + FstOpError: Conversion failed. + """ + cdef string fst_type_string = b"" if fst_type is None else tostring(fst_type) + cdef unique_ptr[fst.FstClass] tfst + tfst.reset(fst.Convert(deref(ifst._fst), fst_type_string)) + # Script-land Convert returns a null pointer to signal failure. + if tfst.get() == NULL: + raise FstOpError("Conversion to {!r} failed".format(fst_type)) + return _init_XFst(tfst.release()) + + +cpdef _MutableFst determinize(_Fst ifst, + float delta=fst.kShortestDelta, + det_type=b"functional", + int64 nstate=fst.kNoStateId, + int64 subsequential_label=0, + weight=None, + bool increment_subsequential_label=False): + """ + determinize(ifst, delta=1e-6, det_type="functional", + nstate=NO_STATE_ID, subsequential_label=0, weight=None, + incremental_subsequential_label=False) + + Constructively determinizes a weighted FST. + + This operations creates an equivalent FST that has the property that no + state has two transitions with the same input label. For this algorithm, + epsilon transitions are treated as regular symbols (cf. `rmepsilon`). + + Args: + ifst: The input FST. + delta: Comparison/quantization delta. + det_type: Type of determinization; one of: "functional" (input transducer is + functional), "nonfunctional" (input transducer is not functional) and + disambiguate" (input transducer is not functional but only keep the min + of ambiguous outputs). + nstate: State number threshold. + subsequential_label: Input label of arc corresponding to residual final + output when producing a subsequential transducer. + weight: A Weight or weight string indicating the desired weight threshold + below which paths are pruned; if omitted, no paths are pruned. + increment_subsequential_label: Increment subsequential when creating + several arcs for the residual final output at a given state. + + Returns: + An equivalent deterministic FST. + + Raises: + FstArgError: Unknown determinization type. + + See also: `disambiguate`, `rmepsilon`. + """ + cdef unique_ptr[fst.VectorFstClass] tfst + tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + # Threshold is set to semiring Zero (no pruning) if weight unspecified. + cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), + weight) + cdef fst.DeterminizeType determinize_type_enum + if not fst.GetDeterminizeType(tostring(det_type), + addr(determinize_type_enum)): + raise FstArgError("Unknown determinization type: {!r}".format(det_type)) + cdef unique_ptr[fst.DeterminizeOptions] opts + opts.reset(new fst.DeterminizeOptions(delta, wc, nstate, subsequential_label, + determinize_type_enum, + increment_subsequential_label)) + fst.Determinize(deref(ifst._fst), tfst.get(), deref(opts)) + return _init_MutableFst(tfst.release()) + + +cpdef _MutableFst difference(_Fst ifst1, + _Fst ifst2, + compose_filter=b"auto", + bool connect=True): + """ + difference(ifst1, ifst2, compose_filter="auto", connect=True) + + Constructively computes the difference of two FSTs. + + This operation computes the difference between two FSAs. Only strings that are + in the first automaton but not in second are retained in the result. The first + argument must be an acceptor; the second argument must be an unweighted, + epsilon-free, deterministic acceptor. The output labels of the first + transducer or the input labels of the second transducer must be sorted (or + otherwise support appropriate matchers). + + Args: + ifst1: The first input FST. + ifst2: The second input FST. + compose_filter: A string matching a known composition filter; one of: + "alt_sequence", "auto", "match", "null", "sequence", "trivial". + connect: Should the output FST be trimmed? + + Returns: + An FST representing the difference of the FSTs. + """ + cdef unique_ptr[fst.VectorFstClass] tfst + tfst.reset(new fst.VectorFstClass(ifst1.arc_type())) + cdef unique_ptr[fst.ComposeOptions] opts + opts.reset(new fst.ComposeOptions(connect, _get_compose_filter( + tostring(compose_filter)))) + fst.Difference(deref(ifst1._fst), deref(ifst2._fst), tfst.get(), deref(opts)) + return _init_MutableFst(tfst.release()) + + +cpdef _MutableFst disambiguate(_Fst ifst, + float delta=fst.kDelta, + int64 nstate=fst.kNoStateId, + int64 subsequential_label=0, + weight=None): + """ + disambiguate(ifst, delta=0.0009765625, nstate=NO_STATE_ID, + subsequential_label=0, weight=None): + + Constructively disambiguates a weighted transducer. + + This operation disambiguates a weighted transducer. The result will be an + equivalent FST that has the property that no two successful paths have the + same input labeling. For this algorithm, epsilon transitions are treated as + regular symbols (cf. `rmepsilon`). + + Args: + ifst: The input FST. + delta: Comparison/quantization delta. + nstate: State number threshold. + subsequential_label: Input label of arc corresponding to residual final + output when producing a subsequential transducer. + weight: A Weight or weight string indicating the desired weight threshold + below which paths are pruned; if omitted, no paths are pruned. + + Returns: + An equivalent disambiguated FST. + + See also: `determinize`, `rmepsilon`. + """ + cdef unique_ptr[fst.VectorFstClass] tfst + tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + # Threshold is set to semiring Zero (no pruning) if no weight is specified. + cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), + weight) + cdef unique_ptr[fst.DisambiguateOptions] opts + opts.reset(new fst.DisambiguateOptions(delta, wc, nstate, + subsequential_label)) + fst.Disambiguate(deref(ifst._fst), tfst.get(), deref(opts)) + return _init_MutableFst(tfst.release()) + + +cpdef _MutableFst epsnormalize(_Fst ifst, bool eps_norm_output=False): + """ + epsnormalize(ifst, eps_norm_output=False) + + Constructively epsilon-normalizes an FST. + + This operation creates an equivalent FST that is epsilon-normalized. An + acceptor is epsilon-normalized if it it is epsilon-removed (cf. `rmepsilon`). + A transducer is input epsilon-normalized if, in addition, along any path, all + arcs with epsilon input labels follow all arcs with non-epsilon input labels. + Output epsilon-normalized is defined similarly. The input FST must be + functional. + + Args: + ifst: The input FST. + eps_norm_output: Should the FST be output epsilon-normalized? + + Returns: + An equivalent epsilon-normalized FST. + + See also: `rmepsilon`. + """ + cdef unique_ptr[fst.VectorFstClass] tfst + tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + fst.EpsNormalize(deref(ifst._fst), tfst.get(), fst.EPS_NORM_OUTPUT if + eps_norm_output else + fst.EPS_NORM_INPUT) + return _init_MutableFst(tfst.release()) + + +cpdef bool equal(_Fst ifst1, _Fst ifst2, float delta=fst.kDelta): + """ + equal(ifst1, ifst2, delta=0.0009765625) + + Are two FSTs equal? + + This function tests whether two FSTs have the same states with the same + numbering and the same transitions with the same labels and weights in the + same order. + + Args: + ifst1: The first input FST. + ifst2: The second input FST. + delta: Comparison/quantization delta. + + Returns: + True if the FSTs satisfy the above condition, else False. + + See also: `equivalent`, `isomorphic`, `randequivalent`. + """ + return fst.Equal(deref(ifst1._fst), deref(ifst2._fst), delta) + + +cpdef bool equivalent(_Fst ifst1, _Fst ifst2, float delta=fst.kDelta) except *: + """ + equivalent(ifst1, ifst2, delta=0.0009765625) + + Are the two acceptors equivalent? + + This operation tests whether two epsilon-free deterministic weighted + acceptors are equivalent, that is if they accept the same strings with the + same weights. + + Args: + ifst1: The first input FST. + ifst2: The second input FST. + delta: Comparison/quantization delta. + + Returns: + True if the FSTs satisfy the above condition, else False. + + See also: `equal`, `isomorphic`, `randequivalent`. + """ + return fst.Equivalent(deref(ifst1._fst), deref(ifst2._fst), delta) + + +cpdef _MutableFst intersect(_Fst ifst1, + _Fst ifst2, + compose_filter=b"auto", + bool connect=True): + """ + intersect(ifst1, ifst2, compose_filter="auto", connect=True) + + Constructively intersects two FSTs. + + This operation computes the intersection (Hadamard product) of two FSTs. + Only strings that are in both automata are retained in the result. The two + arguments must be acceptors. One of the arguments must be label-sorted (or + otherwise support appropriate matchers). + + Args: + ifst1: The first input FST. + ifst2: The second input FST. + compose_filter: A string matching a known composition filter; one of: + "alt_sequence", "auto", "match", "null", "sequence", "trivial". + connect: Should output be trimmed? + + Returns: + An intersected FST. + """ + cdef unique_ptr[fst.VectorFstClass] tfst + tfst.reset(new fst.VectorFstClass(ifst1.arc_type())) + cdef unique_ptr[fst.ComposeOptions] opts + opts.reset(new fst.ComposeOptions(connect, + _get_compose_filter(tostring(compose_filter)))) + fst.Intersect(deref(ifst1._fst), deref(ifst2._fst), tfst.get(), deref(opts)) + return _init_MutableFst(tfst.release()) + + +cpdef bool isomorphic(_Fst ifst1, _Fst ifst2, float delta=fst.kDelta): + """ + isomorphic(ifst1, ifst2, delta=0.0009765625) + + Are the two acceptors isomorphic? + + This operation determines if two transducers with a certain required + determinism have the same states, irrespective of numbering, and the same + transitions with the same labels and weights, irrespective of ordering. In + other words, FSTs A, B are isomorphic if and only if the states of A can be + renumbered and the transitions leaving each state reordered so the two are + equal (according to the definition given in `equal`). + + Args: + ifst1: The first input FST. + ifst2: The second input FST. + delta: Comparison/quantization delta. + + Returns: + True if the two transducers satisfy the above condition, else False. + + See also: `equal`, `equivalent`, `randequivalent`. + """ + return fst.Isomorphic(deref(ifst1._fst), deref(ifst2._fst), delta) + + +cpdef _MutableFst prune(_Fst ifst, + float delta=fst.kDelta, + int64 nstate=fst.kNoStateId, + weight=None): + """ + prune(ifst, delta=0.0009765625, nstate=NO_STATE_ID, weight=None) + + Constructively removes paths with weights below a certain threshold. + + This operation deletes states and arcs in the input FST that do not belong + to a successful path whose weight is no more (w.r.t the natural semiring + order) than the threshold t \otimes-times the weight of the shortest path in + the input FST. Weights must be commutative and have the path property. + + Args: + ifst: The input FST. + delta: Comparison/quantization delta. + nstate: State number threshold. + weight: A Weight or weight string indicating the desired weight threshold + below which paths are pruned; if omitted, no paths are pruned. + + Returns: + A pruned FST. + + See also: The destructive variant. + """ + cdef unique_ptr[fst.VectorFstClass] tfst + tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), weight) + fst.Prune(deref(ifst._fst), tfst.get(), wc, nstate, delta) + return _init_MutableFst(tfst.release()) + + +cpdef _MutableFst push(_Fst ifst, + float delta=fst.kDelta, + bool push_weights=False, + bool push_labels=False, + bool remove_common_affix=False, + bool remove_total_weight=False, + bool to_final=False): + """ + push(ifst, delta=0.0009765625, push_weights=False, push_labels=False, + remove_common_affix=False, remove_total_weight=False, to_final=False) + + Constructively pushes weights/labels towards initial or final states. + + This operation produces an equivalent transducer by pushing the weights + and/or the labels towards the initial state or toward the final states. + + When pushing weights towards the initial state, the sum of the weight of the + outgoing transitions and final weight at any non-initial state is equal to 1 + in the resulting machine. When pushing weights towards the final states, the + sum of the weight of the incoming transitions at any state is equal to 1. + Weights need to be left distributive when pushing towards the initial state + and right distributive when pushing towards the final states. + + Pushing labels towards the initial state consists in minimizing at every + state the length of the longest common prefix of the output labels of the + outgoing paths. Pushing labels towards the final states consists in + minimizing at every state the length of the longest common suffix of the + output labels of the incoming paths. + + Args: + ifst: The input FST. + delta: Comparison/quantization delta. + push_weights: Should weights be pushed? + push_labels: Should labels be pushed? + remove_common_affix: If pushing labels, should common prefix/suffix be + removed? + remove_total_weight: If pushing weights, should total weight be removed? + to_final: Push towards final states? + + Returns: + An equivalent pushed FST. + + See also: The destructive variant. + """ + # This is copied, almost verbatim, from ./fstpush.cc. + cdef unique_ptr[fst.VectorFstClass] tfst + tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + cdef uint32 flags = fst.GetPushFlags(push_weights, push_labels, + remove_common_affix, remove_total_weight) + fst.Push(deref(ifst._fst), tfst.get(), flags, fst.GetReweightType(to_final), + delta) + return _init_MutableFst(tfst.release()) + + +cpdef bool randequivalent(_Fst ifst1, + _Fst ifst2, + int32 npath=1, + float delta=fst.kDelta, + time_t seed=0, + select=b"uniform", + int32 max_length=INT32_MAX) except *: + """ + randequivalent(ifst1, ifst2, npath=1, delta=0.0009765625, seed=0, + select="uniform", max_length=2147483647) + + Are two acceptors stochastically equivalent? + + This operation tests whether two FSTs are equivalent by randomly generating + paths alternatively in each of the two FSTs. For each randomly generated path, + the algorithm computes for each of the two FSTs the sum of the weights of all + the successful paths sharing the same input and output labels as the randomly + generated path and checks that these two values are within `delta`. + + Args: + ifst1: The first input FST. + ifst2: The second input FST. + npath: The number of random paths to generate. + delta: Comparison/quantization delta. + seed: An optional seed value for random path generation; if zero, the + current time and process ID is used. + select: A string matching a known random arc selection type; one of: + "uniform", "log_prob", "fast_log_prob". + max_length: The maximum length of each random path. + + Returns: + True if the two transducers satisfy the above condition, else False. + + See also: `equal`, `equivalent`, `isomorphic`, `randgen`. + """ + cdef fst.RandArcSelection ras = _get_rand_arc_selection(tostring(select)) + cdef unique_ptr[fst.RandGenOptions[fst.RandArcSelection]] opts + # The three trailing options will be ignored by RandEquivalent. + opts.reset(new fst.RandGenOptions[fst.RandArcSelection](ras, max_length, + 1, False, False)) + if seed == 0: + seed = time(NULL) + getpid() + return fst.RandEquivalent(deref(ifst1._fst), deref(ifst2._fst), npath, delta, + seed, deref(opts)) + + +cpdef _MutableFst randgen(_Fst ifst, + int32 npath=1, + time_t seed=0, + select=b"uniform", + int32 max_length=INT32_MAX, + bool weighted=False, + bool remove_total_weight=False): + """ + randgen(ifst, npath=1, seed=0, select="uniform", max_length=2147483647, + weight=False, remove_total_weight=False) + + Randomly generate successful paths in an FST. + + This operation randomly generates a set of successful paths in the input FST. + This relies on a mechanism for selecting arcs, specified using the `select` + argument. The default selector, "uniform", randomly selects a transition + using a uniform distribution. The "log_prob" selector randomly selects a + transition w.r.t. the weights treated as negative log probabilities after + normalizing for the total weight leaving the state. In all cases, finality is + treated as a transition to a super-final state. + + Args: + ifst: The input FST. + npath: The number of random paths to generate. + seed: An optional seed value for random path generation; if zero, the + current time and process ID is used. + select: A string matching a known random arc selection type; one of: + "uniform", "log_prob", "fast_log_prob". + max_length: The maximum length of each random path. + weighted: Should the output be weighted by path count? + remove_total_weight: Should the total weight be removed (ignored when + `weighted` is False)? + + Returns: + An FST containing one or more random paths. + + See also: `randequivalent`. + """ + cdef fst.RandArcSelection ras = _get_rand_arc_selection(tostring(select)) + cdef unique_ptr[fst.RandGenOptions[fst.RandArcSelection]] opts + opts.reset(new fst.RandGenOptions[fst.RandArcSelection](ras, max_length, + npath, weighted, + remove_total_weight)) + cdef unique_ptr[fst.VectorFstClass] tfst + tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + if seed == 0: + seed = time(NULL) + getpid() + fst.RandGen(deref(ifst._fst), tfst.get(), seed, deref(opts)) + return _init_MutableFst(tfst.release()) + + +cpdef _MutableFst replace(pairs, + call_arc_labeling=b"input", + return_arc_labeling=b"neither", + bool epsilon_on_replace=False, + int64 return_label=0): + """ + replace(pairs, call_arc_labeling="input", return_arc_labeling="neither", + epsilon_on_replace=False, return_label=0) + + Recursively replaces arcs in the FST with other FST(s). + + This operation performs the dynamic replacement of arcs in one FST with + another FST, allowing the definition of FSTs analogous to RTNs. It takes as + input a set of pairs of a set of pairs formed by a non-terminal label and + its corresponding FST, and a label identifying the root FST in that set. + The resulting FST is obtained by taking the root FST and recursively replacing + each arc having a nonterminal as output label by its corresponding FST. More + precisely, an arc from state s to state d with (nonterminal) output label n in + this FST is replaced by redirecting this "call" arc to the initial state of a + copy F of the FST for n, and adding "return" arcs from each final state of F + to d. Optional arguments control how the call and return arcs are labeled; by + default, the only non-epsilon label is placed on the call arc. + + Args: + + pairs: An iterable of (nonterminal label, FST) pairs, where the former is an + unsigned integer and the latter is an Fst instance. + call_arc_labeling: A string indicating which call arc labels should be + non-epsilon. One of: "input" (default), "output", "both", "neither". + This value is set to "neither" if epsilon_on_replace is True. + return_arc_labeling: A string indicating which return arc labels should be + non-epsilon. One of: "input", "output", "both", "neither" (default). + This value is set to "neither" if epsilon_on_replace is True. + epsilon_on_replace: Should call and return arcs be epsilon arcs? If True, + this effectively overrides call_arc_labeling and return_arc_labeling, + setting both to "neither". + return_label: The integer label for return arcs. + + Returns: + An FST resulting from expanding the input RTN. + """ + cdef vector[fst.LabelFstClassPair] _pairs + cdef int64 root_label + cdef int64 label + cdef _Fst ifst + it = iter(pairs) + (root_label, ifst) = next(it) + _pairs.push_back(fst.LabelFstClassPair(root_label, ifst._fst.get())) + cdef unique_ptr[fst.VectorFstClass] tfst + tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + for (label, ifst) in it: + _pairs.push_back(fst.LabelFstClassPair(label, ifst._fst.get())) + cdef fst.ReplaceLabelType cal = _get_replace_label_type( + tostring(call_arc_labeling), epsilon_on_replace) + cdef fst.ReplaceLabelType ral = _get_replace_label_type( + tostring(return_arc_labeling), epsilon_on_replace) + cdef unique_ptr[fst.ReplaceOptions] opts + opts.reset(new fst.ReplaceOptions(root_label, cal, ral, return_label)) + fst.Replace(_pairs, tfst.get(), deref(opts)) + return _init_MutableFst(tfst.release()) + + +cpdef _MutableFst reverse(_Fst ifst, bool require_superinitial=True): + """ + reverse(ifst, require_superinitial=True) + + Constructively reverses an FST's transduction. + + This operation reverses an FST. If A transduces string x to y with weight a, + then the reverse of A transduces the reverse of x to the reverse of y with + weight a.Reverse(). (Typically, a = a.Reverse() and Arc = RevArc, e.g., + TropicalWeight and LogWeight.) In general, e.g., when the weights only form a + left or right semiring, the output arc type must match the input arc type. + + Args: + ifst: The input FST. + require_superinitial: Should a superinitial state be created? + + Returns: + A reversed FST. + """ + cdef unique_ptr[fst.VectorFstClass] tfst + tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + fst.Reverse(deref(ifst._fst), tfst.get(), require_superinitial) + return _init_MutableFst(tfst.release()) + + +# Pure C++ helper for shortestdistance. + + +cdef vector[fst.WeightClass] *_shortestdistance(_Fst ifst, + float delta=fst.kShortestDelta, + int64 nstate=fst.kNoStateId, + queue_type=b"auto", + bool reverse=False) except *: + cdef unique_ptr[vector[fst.WeightClass]] distance + distance.reset(new vector[fst.WeightClass]()) + # For scoping reasons, these have to be declared here even though they may + # not be used in all cases. + cdef unique_ptr[fst.ShortestDistanceOptions] opts + if reverse: + # Only the simpler signature supports shortest distance to final states; + # `nstate` and `queue_type` arguments are ignored. + fst.ShortestDistance(deref(ifst._fst), distance.get(), True, delta) + else: + opts.reset(new fst.ShortestDistanceOptions( + _get_queue_type(tostring(queue_type)), fst.ANY_ARC_FILTER, nstate, + delta)) + fst.ShortestDistance(deref(ifst._fst), distance.get(), deref(opts)) + return distance.release() + + +def shortestdistance(_Fst ifst, + float delta=fst.kShortestDelta, + int64 nstate=fst.kNoStateId, + queue_type=b"auto", + bool reverse=False): + """ + shortestdistance(ifst, delta=1e-6, nstate=NO_STATE_ID, + queue_type="auto", reverse=False) + + Compute the shortest distance from the initial or final state. + + This operation computes the shortest distance from the initial state (when + `reverse` is False) or from every state to the final state (when `reverse` is + True). The shortest distance from p to q is the \otimes-sum of the weights of + all the paths between p and q. The weights must be right (if `reverse` is + False) or left (if `reverse` is True) distributive, and k-closed (i.e., 1 + \otimes x \otimes x^2 \otimes ... \otimes x^{k + 1} = 1 \otimes x \otimes x^2 + \otimes ... \otimes x^k; e.g., TropicalWeight). + + Args: + ifst: The input FST. + delta: Comparison/quantization delta. + nstate: State number threshold (ignored if `reverse` is True). + queue_type: A string matching a known queue type; one of: "auto", "fifo", + "lifo", "shortest", "state", "top" (ignored if `reverse` is True). + reverse: Should the reverse distance (from each state to the final state) + be computed? + + Returns: + A list of Weight objects representing the shortest distance for each state. + """ + cdef unique_ptr[vector[fst.WeightClass]] distance + distance.reset(_shortestdistance(ifst, delta, nstate, queue_type, reverse)) + cdef string weight_type = ifst.weight_type() + return [Weight(weight_type, weight.ToString()) for weight in deref(distance)] + + +cpdef _MutableFst shortestpath(_Fst ifst, + float delta=fst.kShortestDelta, + int32 nshortest=1, + int64 nstate=fst.kNoStateId, + queue_type=b"auto", + bool unique=False, + weight=None): + """ + shortestpath(ifst, delta=1e-6, nshortest=1, nstate=NO_STATE_ID, + queue_type="auto", unique=False, weight=None) + + Construct an FST containing the shortest path(s) in the input FST. + + This operation produces an FST containing the n-shortest paths in the input + FST. The n-shortest paths are the n-lowest weight paths w.r.t. the natural + semiring order. The single path that can be read from the ith of at most n + transitions leaving the initial state of the resulting FST is the ith + shortest path. The weights need to be right distributive and have the path + property. They also need to be left distributive as well for n-shortest with + n > 1 (e.g., TropicalWeight). + + Args: + ifst: The input FST. + delta: Comparison/quantization delta. + nshortest: The number of paths to return. + nstate: State number threshold. + queue_type: A string matching a known queue type; one of: "auto", "fifo", + "lifo", "shortest", "state", "top". + unique: Should the resulting FST only contain distinct paths? (Requires + the input FST to be an acceptor; epsilons are treated as if they are + regular symbols.) + weight: A Weight or weight string indicating the desired weight threshold + below which paths are pruned; if omitted, no paths are pruned. + + Returns: + An FST containing the n-shortest paths. + """ + cdef unique_ptr[fst.VectorFstClass] tfst + tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + # Threshold is set to semiring Zero (no pruning) if no weight is specified. + cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), weight) + cdef unique_ptr[fst.ShortestPathOptions] opts + opts.reset(new fst.ShortestPathOptions(_get_queue_type(tostring(queue_type)), + nshortest, unique, delta, wc, nstate)) + fst.ShortestPath(deref(ifst._fst), tfst.get(), deref(opts)) + return _init_MutableFst(tfst.release()) + + +cpdef _Fst statemap(_Fst ifst, map_type): + """ + state_map(ifst, map_type) + + Constructively applies a transform to all states. + + This operation transforms each state according to the requested map type. + Note that currently, only one state-mapping operation is supported. + + Args: + ifst: The input FST. + map_type: A string matching a known mapping operation; one of: "arc_sum" + (sum weights of identically-labeled multi-arcs), "arc_unique" (deletes + non-unique identically-labeled multi-arcs). + + Returns: + An FST with states remapped. + + Raises: + FstArgError: Unknown map type. + + See also: `arcmap`. + """ + return _map(ifst, fst.kDelta, map_type, 1., None) + + +cpdef _MutableFst synchronize(_Fst ifst): + """ + synchronize(ifst) + + Constructively synchronizes an FST. + + This operation synchronizes a transducer. The result will be an equivalent + FST that has the property that during the traversal of a path, the delay is + either zero or strictly increasing, where the delay is the difference between + the number of non-epsilon output labels and input labels along the path. For + the algorithm to terminate, the input transducer must have bounded delay, + i.e., the delay of every cycle must be zero. + + Args: + ifst: The input FST. + + Returns: + An equivalent synchronized FST. + """ + cdef unique_ptr[fst.VectorFstClass] tfst + tfst.reset(new fst.VectorFstClass(ifst.arc_type())) + fst.Synchronize(deref(ifst._fst), tfst.get()) + return _init_MutableFst(tfst.release()) + + +## Compiler. + + +cdef class Compiler(object): + + """ + Compiler(fst_type="vector", arc_type="standard", isymbols=None, + osymbols=None, ssymbols=None, acceptor=False, keep_isymbols=False, + keep_osymbols=False, keep_state_numbering=False, + allow_negative_labels=False) + + Class used to compile FSTs from strings. + + This class is used to compile FSTs specified using the AT&T FSM library + format described here: + + http://web.eecs.umich.edu/~radev/NLP-fall2015/resources/fsm_archive/fsm.5.html + + This is the same format used by the `fstcompile` executable. + + Compiler options (symbol tables, etc.) are set at construction time. + + compiler = fst.Compiler(isymbols=ascii_syms, osymbols=ascii_syms) + + Once constructed, Compiler instances behave like a file handle opened for + writing: + + # /ba+/ + print >> compiler, "0 1 50 50" + print >> compiler, "1 2 49 49" + print >> compiler, "2 2 49 49" + print >> compiler, "2" + + The `compile` method returns an actual FST instance: + + sheep_machine = compiler.compile() + + Compilation flushes the internal buffer, so the compiler instance can be + reused to compile new machines with the same symbol tables (etc.) + + Args: + fst_type: A string indicating the container type for the compiled FST. + arc_type: A string indicating the arc type for the compiled FST. + isymbols: An optional SymbolTable used to label input symbols. + osymbols: An optional SymbolTable used to label output symbols. + ssymbols: An optional SymbolTable used to label states. + acceptor: Should the FST be rendered in acceptor format if possible? + keep_isymbols: Should the input symbol table be stored in the FST? + keep_osymbols: Should the output symbol table be stored in the FST? + keep_state_numbering: Should the state numbering be preserved? + allow_negative_labels: Should negative labels be allowed? (Not + recommended; may cause conflicts). + """ + + def __cinit__(self, + string fst_type=b"vector", + string arc_type=b"standard", + SymbolTable isymbols=None, + SymbolTable osymbols=None, + SymbolTable ssymbols=None, + bool acceptor=False, + bool keep_isymbols=False, + bool keep_osymbols=False, + bool keep_state_numbering=False, + bool allow_negative_labels=False): + self._sstrm.reset(new stringstream()) + self._fst_type = tostring(fst_type) + self._arc_type = tostring(arc_type) + self._isymbols = NULL + if isymbols is not None: + self._isymbols = isymbols._table + self._osymbols = NULL + if osymbols is not None: + self._osymbols = osymbols._table + self._ssymbols = NULL + if ssymbols is not None: + self._ssymbols = ssymbols._table + self._acceptor = acceptor + self._keep_isymbols = keep_isymbols + self._keep_osymbols = keep_osymbols + self._keep_state_numbering = keep_state_numbering + self._allow_negative_labels = allow_negative_labels + + cpdef _Fst compile(self): + """ + compile() + + Compiles the FST in the compiler string buffer. + + This method compiles the FST and returns the resulting machine. + + Returns: + The FST described by the compiler string buffer. + + Raises: + FstOpError: Compilation failed. + """ + cdef unique_ptr[fst.FstClass] tfst + tfst.reset(fst.CompileFstInternal(deref(self._sstrm), + b"", self._fst_type, self._arc_type, self._isymbols, + self._osymbols, self._ssymbols, self._acceptor, self._keep_isymbols, + self._keep_osymbols, self._keep_state_numbering, + self._allow_negative_labels)) + self._sstrm.reset(new stringstream()) + if tfst.get() == NULL: + raise FstOpError("Compilation failed") + return _init_XFst(tfst.release()) + + cpdef void write(self, expression): + """ + write(expression) + + Writes a string into the compiler string buffer. + + This method adds a line to the compiler string buffer. It is normally + invoked using the right shift operator, like so: + + compiler = fst.Compiler() + print >> compiler, "0 0 49 49" + print >> compiler, "0" + + Args: + expression: A string expression to add to compiler string buffer. + """ + deref(self._sstrm) << tostring(expression) + + +## FarReader and FarWriter. + + +cdef class FarReader(object): + + """ + (No constructor.) + + FAR ("Fst ARchive") reader object. + + This class is used to read a FAR from disk. FARs contain one or more FSTs (of + the same arc type) indexed by a unique string key. To construct a FarReader + object, use the `open` class method. + + Attributes: + arc_type: A string indicating the arc type. + far_type: A string indicating the FAR type. + """ + + def __init__(self): + raise FstDeletedConstructorError( + "Cannot construct {}".format(self.__class__.__name__)) + + def __repr__(self): + return "<{} FarReader at 0x{:x}>".format(self.far_type(), id(self)) + + @classmethod + def open(cls, *filenames): + """ + FarReader.open(*filenames) + + Creates a FarReader object. + + This class method creates a FarReader given the string location of one or + more FAR files on disk. + + Args: + *filenames: The string location of one or more input FAR files. + + Returns: + A new FarReader instance. + + Raises: + FstIOError: Read failed. + """ + filenames = [tostring(filename) for filename in filenames] + cdef unique_ptr[fst.FarReaderClass] tfar + tfar.reset(fst.FarReaderClass.Open(filenames)) + if tfar.get() == NULL: + raise FstIOError("Read failed: {!r}".format(filenames)) + cdef FarReader result = FarReader.__new__(FarReader) + result._reader.reset(tfar.release()) + return result + + cpdef string arc_type(self): + """ + arc_type(self) + + Returns a string indicating the arc type. + """ + return self._reader.get().ArcType() + + cpdef bool done(self): + """ + done(self) + + Indicates whether the iterator is exhausted or not. + + Returns: + True if the iterator is exhausted, False otherwise. + """ + return self._reader.get().Done() + + cpdef bool error(self): + """ + error(self) + + Indicates whether the FarReader has encountered an error. + + Returns: + True if the FarReader is in an errorful state, False otherwise. + """ + return self._reader.get().Error() + + cpdef string far_type(self): + return fst.GetFarTypeString(self._reader.get().Type()) + + cpdef bool find(self, key) except *: + """ + find(self, key) + + Sets the current position to the first entry greater than or equal to the + key (a string) and indicates whether or not a match was found. + + Args: + key: A string key. + + Returns: + True if the key was found, False otherwise. + """ + return self._reader.get().Find(tostring(key)) + + cpdef _Fst get_fst(self): + """ + get_fst(self) + + Returns the FST at the current position. + + Returns: + A copy of the FST at the current position. + """ + return _init_XFst(new fst.FstClass( + deref(self._reader.get().GetFstClass()))) + + cpdef string get_key(self): + """ + get_key(self) + + Returns the string key at the current position. + + Returns: + The string key at the current position. + """ + return self._reader.get().GetKey() + + cpdef void next(self): + """ + next(self) + + Advances the iterator. + """ + self._reader.get().Next() + + cpdef void reset(self): + """ + reset(self) + + Resets the iterator to the initial position. + """ + self._reader.get().Reset() + + def __getitem__(self, key): + cdef string ckey = tostring(key) + if self.get_key() == ckey or self._reader.get().Find(ckey): + return self.get_fst() + raise KeyError(key) + + +cdef class FarWriter(object): + + """ + (No constructor.) + + FAR ("Fst ARchive") writer object. + + This class is used to write FSTs (of the same arc type) to a FAR on disk. To + construct a FarWriter, use the `create` class method. + + Note that the data is not guaranteed to flush to disk until the FarWriter + is garbage-collected. If a FarWriter has been assigned to only one variable, + then calling `del` on that variable should decrement the object's reference + count from 1 to 0, triggering a flush to disk on the next GC cycle. + + Attributes: + arc_type: A string indicating the arc type. + far_type: A string indicating the FAR type. + """ + + def __init__(self): + raise FstDeletedConstructorError( + "Cannot construct {}".format(self.__class__.__name__)) + + def __repr__(self): + return "<{} FarWriter at 0x{:x}>".format(self.far_type(), id(self)) + + @classmethod + def create(cls, filename, arc_type=b"standard", far_type=b"default"): + """ + FarWriter. + + Creates a FarWriter object. + + This class method creates a FarWriter given the desired output location, + arc type, and FAR type. + + Args: + filename: The string location for the output FAR files. + arc_type: A string indicating the arc type. + far_type: A string indicating the FAR type; one of: "fst", "stlist", + "sttable", "sstable", "default". + + Returns: + A new FarWriter instance. + + Raises: + FstIOError: Read failed. + """ + cdef fst.FarType ft = fst.GetFarType(tostring(far_type)) + cdef fst.FarWriterClass *tfar = fst.FarWriterClass.Create( + tostring(filename), tostring(arc_type), ft) + if tfar == NULL: + raise FstIOError("Open failed: {!r}".format(filename)) + cdef FarWriter result = FarWriter.__new__(FarWriter) + result._writer.reset(tfar) + return result + + # NB: Invoking this method may be dangerous: calling any other method on the + # instance after this is invoked may result in a null dereference. + cdef void close(self): + self._writer.reset() + + cpdef void add(self, key, _Fst ifst) except *: + """ + add(self, key, ifst) + + Adds an FST to the FAR. + + This method adds an FST to the FAR which can be retrieved with the + specified string key. + + Args: + key: The string used to key the input FST. + ifst: The FST to write to the FAR. + + Raises: + FstArgError: Key out of order. + FstOpError: Incompatible or invalid arc type. + """ + # Failure here results from passing an FST with a different arc type than + # used by the FAR was initialized to use. + if not self._writer.get().Add(tostring(key), deref(ifst._fst)): + raise FstOpError("Incompatible or invalid arc type") + # An error here usually indicates a key out of order. + if self._writer.get().Error(): + raise FstArgError("Key out of order") + + cpdef string arc_type(self): + """ + arc_type(self) + + Returns a string indicating the arc type. + """ + return self._writer.get().ArcType() + + cpdef bool error(self): + """ + error(self) + + Indicates whether the FarWriter has encountered an error. + + Returns: + True if the FarWriter is in an errorful state, False otherwise. + """ + return self._writer.get().Error() + + cpdef string far_type(self): + """ + far_type(self) + + Returns a string indicating the FAR type. + """ + return fst.GetFarTypeString(self._writer.get().Type()) + + # Dictionary-like assignment. + def __setitem__(self, key, _Fst fst): + self.add(key, fst) + + +## Cleanup operations for module entrance and exit. + + +# Masks fst_error_fatal flags while this module is running, returning to the +# previous state upon module exit. + + +_fst_error_fatal_old = fst.FLAGS_fst_error_fatal +fst.FLAGS_fst_error_fatal = False + + +@atexit.register +def _reset_fst_error_fatal(): + fst.FLAGS_fst_error_fatal = _fst_error_fatal_old diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/special/Makefile.am b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/special/Makefile.am new file mode 100644 index 0000000000..68bc609beb --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/special/Makefile.am @@ -0,0 +1,33 @@ +AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) + +if HAVE_BIN +bin_PROGRAMS = fstspecial + +LDADD = ../../script/libfstscript.la \ + ../../lib/libfst.la -lm $(DL_LIBS) + +fstspecial_SOURCES = ../../bin/fstconvert.cc ../../bin/fstconvert-main.cc \ + phi-fst.cc rho-fst.cc sigma-fst.cc +fstspecial_CPPFLAGS = $(AM_CPPFLAGS) +endif + +libfstdir = @libfstdir@ +libfst_LTLIBRARIES = phi-fst.la rho-fst.la sigma-fst.la + +lib_LTLIBRARIES = libfstspecial.la + +libfstspecial_la_SOURCES = phi-fst.cc rho-fst.cc sigma-fst.cc +libfstspecial_la_LDFLAGS = -version-info 10:0:0 -lm $(DL_LIBS) +libfstspecial_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS) + +phi_fst_la_SOURCES = phi-fst.cc +phi_fst_la_LDFLAGS = -module +phi_fst_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS) + +rho_fst_la_SOURCES = rho-fst.cc +rho_fst_la_LDFLAGS = -module +rho_fst_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS) + +sigma_fst_la_SOURCES = sigma-fst.cc +sigma_fst_la_LDFLAGS = -module +sigma_fst_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS) diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/special/Makefile.in b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/special/Makefile.in new file mode 100644 index 0000000000..09d6cca958 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/special/Makefile.in @@ -0,0 +1,909 @@ +# Makefile.in generated by automake 1.14.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2013 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + + +VPATH = @srcdir@ +am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +@HAVE_BIN_TRUE@bin_PROGRAMS = fstspecial$(EXEEXT) +subdir = src/extensions/special +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ + $(top_srcdir)/depcomp +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \ + $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ + $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ + $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h \ + $(top_builddir)/src/include/fst/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__uninstall_files_from_dir = { \ + test -z "$$files" \ + || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && rm -f $$files; }; \ + } +am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)" \ + "$(DESTDIR)$(bindir)" +LTLIBRARIES = $(lib_LTLIBRARIES) $(libfst_LTLIBRARIES) +am__DEPENDENCIES_1 = +libfstspecial_la_DEPENDENCIES = ../../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am_libfstspecial_la_OBJECTS = phi-fst.lo rho-fst.lo sigma-fst.lo +libfstspecial_la_OBJECTS = $(am_libfstspecial_la_OBJECTS) +AM_V_lt = $(am__v_lt_@AM_V@) +am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) +am__v_lt_0 = --silent +am__v_lt_1 = +libfstspecial_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) $(libfstspecial_la_LDFLAGS) \ + $(LDFLAGS) -o $@ +phi_fst_la_DEPENDENCIES = ../../lib/libfst.la $(am__DEPENDENCIES_1) +am_phi_fst_la_OBJECTS = phi-fst.lo +phi_fst_la_OBJECTS = $(am_phi_fst_la_OBJECTS) +phi_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(phi_fst_la_LDFLAGS) $(LDFLAGS) -o $@ +rho_fst_la_DEPENDENCIES = ../../lib/libfst.la $(am__DEPENDENCIES_1) +am_rho_fst_la_OBJECTS = rho-fst.lo +rho_fst_la_OBJECTS = $(am_rho_fst_la_OBJECTS) +rho_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(rho_fst_la_LDFLAGS) $(LDFLAGS) -o $@ +sigma_fst_la_DEPENDENCIES = ../../lib/libfst.la $(am__DEPENDENCIES_1) +am_sigma_fst_la_OBJECTS = sigma-fst.lo +sigma_fst_la_OBJECTS = $(am_sigma_fst_la_OBJECTS) +sigma_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(sigma_fst_la_LDFLAGS) $(LDFLAGS) -o $@ +PROGRAMS = $(bin_PROGRAMS) +am__fstspecial_SOURCES_DIST = ../../bin/fstconvert.cc \ + ../../bin/fstconvert-main.cc phi-fst.cc rho-fst.cc \ + sigma-fst.cc +am__dirstamp = $(am__leading_dot)dirstamp +@HAVE_BIN_TRUE@am_fstspecial_OBJECTS = \ +@HAVE_BIN_TRUE@ ../../bin/fstspecial-fstconvert.$(OBJEXT) \ +@HAVE_BIN_TRUE@ ../../bin/fstspecial-fstconvert-main.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstspecial-phi-fst.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstspecial-rho-fst.$(OBJEXT) \ +@HAVE_BIN_TRUE@ fstspecial-sigma-fst.$(OBJEXT) +fstspecial_OBJECTS = $(am_fstspecial_OBJECTS) +fstspecial_LDADD = $(LDADD) +@HAVE_BIN_TRUE@fstspecial_DEPENDENCIES = ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1) +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +DEFAULT_INCLUDES = +depcomp = $(SHELL) $(top_srcdir)/depcomp +am__depfiles_maybe = depfiles +am__mv = mv -f +CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CXXFLAGS) $(CXXFLAGS) +AM_V_CXX = $(am__v_CXX_@AM_V@) +am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@) +am__v_CXX_0 = @echo " CXX " $@; +am__v_CXX_1 = +CXXLD = $(CXX) +CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_CXXLD = $(am__v_CXXLD_@AM_V@) +am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@) +am__v_CXXLD_0 = @echo " CXXLD " $@; +am__v_CXXLD_1 = +SOURCES = $(libfstspecial_la_SOURCES) $(phi_fst_la_SOURCES) \ + $(rho_fst_la_SOURCES) $(sigma_fst_la_SOURCES) \ + $(fstspecial_SOURCES) +DIST_SOURCES = $(libfstspecial_la_SOURCES) $(phi_fst_la_SOURCES) \ + $(rho_fst_la_SOURCES) $(sigma_fst_la_SOURCES) \ + $(am__fstspecial_SOURCES_DIST) +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DL_LIBS = @DL_LIBS@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PYTHON = @PYTHON@ +PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@ +PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ +PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@ +PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@ +PYTHON_LDFLAGS = @PYTHON_LDFLAGS@ +PYTHON_PLATFORM = @PYTHON_PLATFORM@ +PYTHON_PREFIX = @PYTHON_PREFIX@ +PYTHON_SITE_PKG = @PYTHON_SITE_PKG@ +PYTHON_VERSION = @PYTHON_VERSION@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +libfstdir = @libfstdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgpyexecdir = @pkgpyexecdir@ +pkgpythondir = @pkgpythondir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +pyexecdir = @pyexecdir@ +pythondir = @pythondir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) +@HAVE_BIN_TRUE@LDADD = ../../script/libfstscript.la \ +@HAVE_BIN_TRUE@ ../../lib/libfst.la -lm $(DL_LIBS) + +@HAVE_BIN_TRUE@fstspecial_SOURCES = ../../bin/fstconvert.cc ../../bin/fstconvert-main.cc \ +@HAVE_BIN_TRUE@ phi-fst.cc rho-fst.cc sigma-fst.cc + +@HAVE_BIN_TRUE@fstspecial_CPPFLAGS = $(AM_CPPFLAGS) +libfst_LTLIBRARIES = phi-fst.la rho-fst.la sigma-fst.la +lib_LTLIBRARIES = libfstspecial.la +libfstspecial_la_SOURCES = phi-fst.cc rho-fst.cc sigma-fst.cc +libfstspecial_la_LDFLAGS = -version-info 10:0:0 -lm $(DL_LIBS) +libfstspecial_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS) +phi_fst_la_SOURCES = phi-fst.cc +phi_fst_la_LDFLAGS = -module +phi_fst_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS) +rho_fst_la_SOURCES = rho-fst.cc +rho_fst_la_LDFLAGS = -module +rho_fst_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS) +sigma_fst_la_SOURCES = sigma-fst.cc +sigma_fst_la_LDFLAGS = -module +sigma_fst_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS) +all: all-am + +.SUFFIXES: +.SUFFIXES: .cc .lo .o .obj +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/special/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign src/extensions/special/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +install-libLTLIBRARIES: $(lib_LTLIBRARIES) + @$(NORMAL_INSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \ + } + +uninstall-libLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \ + done + +clean-libLTLIBRARIES: + -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES) + @list='$(lib_LTLIBRARIES)'; \ + locs=`for p in $$list; do echo $$p; done | \ + sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ + sort -u`; \ + test -z "$$locs" || { \ + echo rm -f $${locs}; \ + rm -f $${locs}; \ + } + +install-libfstLTLIBRARIES: $(libfst_LTLIBRARIES) + @$(NORMAL_INSTALL) + @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(libfstdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(libfstdir)" || exit 1; \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libfstdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libfstdir)"; \ + } + +uninstall-libfstLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libfstdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libfstdir)/$$f"; \ + done + +clean-libfstLTLIBRARIES: + -test -z "$(libfst_LTLIBRARIES)" || rm -f $(libfst_LTLIBRARIES) + @list='$(libfst_LTLIBRARIES)'; \ + locs=`for p in $$list; do echo $$p; done | \ + sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ + sort -u`; \ + test -z "$$locs" || { \ + echo rm -f $${locs}; \ + rm -f $${locs}; \ + } + +libfstspecial.la: $(libfstspecial_la_OBJECTS) $(libfstspecial_la_DEPENDENCIES) $(EXTRA_libfstspecial_la_DEPENDENCIES) + $(AM_V_CXXLD)$(libfstspecial_la_LINK) -rpath $(libdir) $(libfstspecial_la_OBJECTS) $(libfstspecial_la_LIBADD) $(LIBS) + +phi-fst.la: $(phi_fst_la_OBJECTS) $(phi_fst_la_DEPENDENCIES) $(EXTRA_phi_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(phi_fst_la_LINK) -rpath $(libfstdir) $(phi_fst_la_OBJECTS) $(phi_fst_la_LIBADD) $(LIBS) + +rho-fst.la: $(rho_fst_la_OBJECTS) $(rho_fst_la_DEPENDENCIES) $(EXTRA_rho_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(rho_fst_la_LINK) -rpath $(libfstdir) $(rho_fst_la_OBJECTS) $(rho_fst_la_LIBADD) $(LIBS) + +sigma-fst.la: $(sigma_fst_la_OBJECTS) $(sigma_fst_la_DEPENDENCIES) $(EXTRA_sigma_fst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(sigma_fst_la_LINK) -rpath $(libfstdir) $(sigma_fst_la_OBJECTS) $(sigma_fst_la_LIBADD) $(LIBS) +install-binPROGRAMS: $(bin_PROGRAMS) + @$(NORMAL_INSTALL) + @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \ + if test -n "$$list"; then \ + echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \ + fi; \ + for p in $$list; do echo "$$p $$p"; done | \ + sed 's/$(EXEEXT)$$//' | \ + while read p p1; do if test -f $$p \ + || test -f $$p1 \ + ; then echo "$$p"; echo "$$p"; else :; fi; \ + done | \ + sed -e 'p;s,.*/,,;n;h' \ + -e 's|.*|.|' \ + -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \ + sed 'N;N;N;s,\n, ,g' | \ + $(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \ + { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \ + if ($$2 == $$4) files[d] = files[d] " " $$1; \ + else { print "f", $$3 "/" $$4, $$1; } } \ + END { for (d in files) print "f", d, files[d] }' | \ + while read type dir files; do \ + if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \ + test -z "$$files" || { \ + echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \ + $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \ + } \ + ; done + +uninstall-binPROGRAMS: + @$(NORMAL_UNINSTALL) + @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \ + files=`for p in $$list; do echo "$$p"; done | \ + sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \ + -e 's/$$/$(EXEEXT)/' \ + `; \ + test -n "$$list" || exit 0; \ + echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(bindir)" && rm -f $$files + +clean-binPROGRAMS: + @list='$(bin_PROGRAMS)'; test -n "$$list" || exit 0; \ + echo " rm -f" $$list; \ + rm -f $$list || exit $$?; \ + test -n "$(EXEEXT)" || exit 0; \ + list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \ + echo " rm -f" $$list; \ + rm -f $$list +../../bin/$(am__dirstamp): + @$(MKDIR_P) ../../bin + @: > ../../bin/$(am__dirstamp) +../../bin/$(DEPDIR)/$(am__dirstamp): + @$(MKDIR_P) ../../bin/$(DEPDIR) + @: > ../../bin/$(DEPDIR)/$(am__dirstamp) +../../bin/fstspecial-fstconvert.$(OBJEXT): ../../bin/$(am__dirstamp) \ + ../../bin/$(DEPDIR)/$(am__dirstamp) +../../bin/fstspecial-fstconvert-main.$(OBJEXT): \ + ../../bin/$(am__dirstamp) ../../bin/$(DEPDIR)/$(am__dirstamp) + +fstspecial$(EXEEXT): $(fstspecial_OBJECTS) $(fstspecial_DEPENDENCIES) $(EXTRA_fstspecial_DEPENDENCIES) + @rm -f fstspecial$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fstspecial_OBJECTS) $(fstspecial_LDADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + -rm -f ../../bin/*.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@../../bin/$(DEPDIR)/fstspecial-fstconvert-main.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@../../bin/$(DEPDIR)/fstspecial-fstconvert.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstspecial-phi-fst.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstspecial-rho-fst.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstspecial-sigma-fst.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/phi-fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rho-fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sigma-fst.Plo@am__quote@ + +.cc.o: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $< + +.cc.obj: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cc.lo: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ +@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $< + +../../bin/fstspecial-fstconvert.o: ../../bin/fstconvert.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT ../../bin/fstspecial-fstconvert.o -MD -MP -MF ../../bin/$(DEPDIR)/fstspecial-fstconvert.Tpo -c -o ../../bin/fstspecial-fstconvert.o `test -f '../../bin/fstconvert.cc' || echo '$(srcdir)/'`../../bin/fstconvert.cc +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) ../../bin/$(DEPDIR)/fstspecial-fstconvert.Tpo ../../bin/$(DEPDIR)/fstspecial-fstconvert.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../../bin/fstconvert.cc' object='../../bin/fstspecial-fstconvert.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o ../../bin/fstspecial-fstconvert.o `test -f '../../bin/fstconvert.cc' || echo '$(srcdir)/'`../../bin/fstconvert.cc + +../../bin/fstspecial-fstconvert.obj: ../../bin/fstconvert.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT ../../bin/fstspecial-fstconvert.obj -MD -MP -MF ../../bin/$(DEPDIR)/fstspecial-fstconvert.Tpo -c -o ../../bin/fstspecial-fstconvert.obj `if test -f '../../bin/fstconvert.cc'; then $(CYGPATH_W) '../../bin/fstconvert.cc'; else $(CYGPATH_W) '$(srcdir)/../../bin/fstconvert.cc'; fi` +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) ../../bin/$(DEPDIR)/fstspecial-fstconvert.Tpo ../../bin/$(DEPDIR)/fstspecial-fstconvert.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../../bin/fstconvert.cc' object='../../bin/fstspecial-fstconvert.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o ../../bin/fstspecial-fstconvert.obj `if test -f '../../bin/fstconvert.cc'; then $(CYGPATH_W) '../../bin/fstconvert.cc'; else $(CYGPATH_W) '$(srcdir)/../../bin/fstconvert.cc'; fi` + +../../bin/fstspecial-fstconvert-main.o: ../../bin/fstconvert-main.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT ../../bin/fstspecial-fstconvert-main.o -MD -MP -MF ../../bin/$(DEPDIR)/fstspecial-fstconvert-main.Tpo -c -o ../../bin/fstspecial-fstconvert-main.o `test -f '../../bin/fstconvert-main.cc' || echo '$(srcdir)/'`../../bin/fstconvert-main.cc +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) ../../bin/$(DEPDIR)/fstspecial-fstconvert-main.Tpo ../../bin/$(DEPDIR)/fstspecial-fstconvert-main.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../../bin/fstconvert-main.cc' object='../../bin/fstspecial-fstconvert-main.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o ../../bin/fstspecial-fstconvert-main.o `test -f '../../bin/fstconvert-main.cc' || echo '$(srcdir)/'`../../bin/fstconvert-main.cc + +../../bin/fstspecial-fstconvert-main.obj: ../../bin/fstconvert-main.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT ../../bin/fstspecial-fstconvert-main.obj -MD -MP -MF ../../bin/$(DEPDIR)/fstspecial-fstconvert-main.Tpo -c -o ../../bin/fstspecial-fstconvert-main.obj `if test -f '../../bin/fstconvert-main.cc'; then $(CYGPATH_W) '../../bin/fstconvert-main.cc'; else $(CYGPATH_W) '$(srcdir)/../../bin/fstconvert-main.cc'; fi` +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) ../../bin/$(DEPDIR)/fstspecial-fstconvert-main.Tpo ../../bin/$(DEPDIR)/fstspecial-fstconvert-main.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../../bin/fstconvert-main.cc' object='../../bin/fstspecial-fstconvert-main.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o ../../bin/fstspecial-fstconvert-main.obj `if test -f '../../bin/fstconvert-main.cc'; then $(CYGPATH_W) '../../bin/fstconvert-main.cc'; else $(CYGPATH_W) '$(srcdir)/../../bin/fstconvert-main.cc'; fi` + +fstspecial-phi-fst.o: phi-fst.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fstspecial-phi-fst.o -MD -MP -MF $(DEPDIR)/fstspecial-phi-fst.Tpo -c -o fstspecial-phi-fst.o `test -f 'phi-fst.cc' || echo '$(srcdir)/'`phi-fst.cc +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/fstspecial-phi-fst.Tpo $(DEPDIR)/fstspecial-phi-fst.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='phi-fst.cc' object='fstspecial-phi-fst.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fstspecial-phi-fst.o `test -f 'phi-fst.cc' || echo '$(srcdir)/'`phi-fst.cc + +fstspecial-phi-fst.obj: phi-fst.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fstspecial-phi-fst.obj -MD -MP -MF $(DEPDIR)/fstspecial-phi-fst.Tpo -c -o fstspecial-phi-fst.obj `if test -f 'phi-fst.cc'; then $(CYGPATH_W) 'phi-fst.cc'; else $(CYGPATH_W) '$(srcdir)/phi-fst.cc'; fi` +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/fstspecial-phi-fst.Tpo $(DEPDIR)/fstspecial-phi-fst.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='phi-fst.cc' object='fstspecial-phi-fst.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fstspecial-phi-fst.obj `if test -f 'phi-fst.cc'; then $(CYGPATH_W) 'phi-fst.cc'; else $(CYGPATH_W) '$(srcdir)/phi-fst.cc'; fi` + +fstspecial-rho-fst.o: rho-fst.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fstspecial-rho-fst.o -MD -MP -MF $(DEPDIR)/fstspecial-rho-fst.Tpo -c -o fstspecial-rho-fst.o `test -f 'rho-fst.cc' || echo '$(srcdir)/'`rho-fst.cc +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/fstspecial-rho-fst.Tpo $(DEPDIR)/fstspecial-rho-fst.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='rho-fst.cc' object='fstspecial-rho-fst.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fstspecial-rho-fst.o `test -f 'rho-fst.cc' || echo '$(srcdir)/'`rho-fst.cc + +fstspecial-rho-fst.obj: rho-fst.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fstspecial-rho-fst.obj -MD -MP -MF $(DEPDIR)/fstspecial-rho-fst.Tpo -c -o fstspecial-rho-fst.obj `if test -f 'rho-fst.cc'; then $(CYGPATH_W) 'rho-fst.cc'; else $(CYGPATH_W) '$(srcdir)/rho-fst.cc'; fi` +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/fstspecial-rho-fst.Tpo $(DEPDIR)/fstspecial-rho-fst.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='rho-fst.cc' object='fstspecial-rho-fst.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fstspecial-rho-fst.obj `if test -f 'rho-fst.cc'; then $(CYGPATH_W) 'rho-fst.cc'; else $(CYGPATH_W) '$(srcdir)/rho-fst.cc'; fi` + +fstspecial-sigma-fst.o: sigma-fst.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fstspecial-sigma-fst.o -MD -MP -MF $(DEPDIR)/fstspecial-sigma-fst.Tpo -c -o fstspecial-sigma-fst.o `test -f 'sigma-fst.cc' || echo '$(srcdir)/'`sigma-fst.cc +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/fstspecial-sigma-fst.Tpo $(DEPDIR)/fstspecial-sigma-fst.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='sigma-fst.cc' object='fstspecial-sigma-fst.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fstspecial-sigma-fst.o `test -f 'sigma-fst.cc' || echo '$(srcdir)/'`sigma-fst.cc + +fstspecial-sigma-fst.obj: sigma-fst.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fstspecial-sigma-fst.obj -MD -MP -MF $(DEPDIR)/fstspecial-sigma-fst.Tpo -c -o fstspecial-sigma-fst.obj `if test -f 'sigma-fst.cc'; then $(CYGPATH_W) 'sigma-fst.cc'; else $(CYGPATH_W) '$(srcdir)/sigma-fst.cc'; fi` +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/fstspecial-sigma-fst.Tpo $(DEPDIR)/fstspecial-sigma-fst.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='sigma-fst.cc' object='fstspecial-sigma-fst.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fstspecial-sigma-fst.obj `if test -f 'sigma-fst.cc'; then $(CYGPATH_W) 'sigma-fst.cc'; else $(CYGPATH_W) '$(srcdir)/sigma-fst.cc'; fi` + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-am +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-am + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscopelist: cscopelist-am + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(LTLIBRARIES) $(PROGRAMS) +install-binPROGRAMS: install-libLTLIBRARIES + +installdirs: + for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)" "$(DESTDIR)$(bindir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + -rm -f ../../bin/$(DEPDIR)/$(am__dirstamp) + -rm -f ../../bin/$(am__dirstamp) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \ + clean-libfstLTLIBRARIES clean-libtool mostlyclean-am + +distclean: distclean-am + -rm -rf ../../bin/$(DEPDIR) ./$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: install-libfstLTLIBRARIES + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: install-binPROGRAMS install-libLTLIBRARIES + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ../../bin/$(DEPDIR) ./$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-binPROGRAMS uninstall-libLTLIBRARIES \ + uninstall-libfstLTLIBRARIES + +.MAKE: install-am install-strip + +.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \ + clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \ + clean-libfstLTLIBRARIES clean-libtool cscopelist-am ctags \ + ctags-am distclean distclean-compile distclean-generic \ + distclean-libtool distclean-tags distdir dvi dvi-am html \ + html-am info info-am install install-am install-binPROGRAMS \ + install-data install-data-am install-dvi install-dvi-am \ + install-exec install-exec-am install-html install-html-am \ + install-info install-info-am install-libLTLIBRARIES \ + install-libfstLTLIBRARIES install-man install-pdf \ + install-pdf-am install-ps install-ps-am install-strip \ + installcheck installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-compile \ + mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ + tags tags-am uninstall uninstall-am uninstall-binPROGRAMS \ + uninstall-libLTLIBRARIES uninstall-libfstLTLIBRARIES + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/special/phi-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/special/phi-fst.cc new file mode 100644 index 0000000000..97177bf645 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/special/phi-fst.cc @@ -0,0 +1,34 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +DEFINE_int64(phi_fst_phi_label, 0, + "Label of transitions to be interpreted as phi ('failure') " + "transitions"); +DEFINE_bool(phi_fst_phi_loop, true, + "When true, a phi self loop consumes a symbol"); +DEFINE_string(phi_fst_rewrite_mode, "auto", + "Rewrite both sides when matching? One of:" + " \"auto\" (rewrite iff acceptor), \"always\", \"never\""); + +namespace fst { + +const char phi_fst_type[] = "phi"; +const char input_phi_fst_type[] = "input_phi"; +const char output_phi_fst_type[] = "output_phi"; + +static FstRegisterer PhiFst_StdArc_registerer; +static FstRegisterer PhiFst_LogArc_registerer; +static FstRegisterer PhiFst_Log64Arc_registerer; + +static FstRegisterer InputPhiFst_StdArc_registerer; +static FstRegisterer InputPhiFst_LogArc_registerer; +static FstRegisterer InputPhiFst_Log64Arc_registerer; + +static FstRegisterer OutputPhiFst_StdArc_registerer; +static FstRegisterer OutputPhiFst_LogArc_registerer; +static FstRegisterer OutputPhiFst_Log64Arc_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/special/rho-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/special/rho-fst.cc new file mode 100644 index 0000000000..023d432f13 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/special/rho-fst.cc @@ -0,0 +1,33 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +#include + +DEFINE_int64(rho_fst_rho_label, 0, + "Label of transitions to be interpreted as rho ('rest') " + "transitions"); +DEFINE_string(rho_fst_rewrite_mode, "auto", + "Rewrite both sides when matching? One of:" + " \"auto\" (rewrite iff acceptor), \"always\", \"never\""); + +namespace fst { + +const char rho_fst_type[] = "rho"; +const char input_rho_fst_type[] = "input_rho"; +const char output_rho_fst_type[] = "output_rho"; + +static FstRegisterer RhoFst_StdArc_registerer; +static FstRegisterer RhoFst_LogArc_registerer; +static FstRegisterer RhoFst_Log64Arc_registerer; + +static FstRegisterer InputRhoFst_StdArc_registerer; +static FstRegisterer InputRhoFst_LogArc_registerer; +static FstRegisterer InputRhoFst_Log64Arc_registerer; + +static FstRegisterer OutputRhoFst_StdArc_registerer; +static FstRegisterer OutputRhoFst_LogArc_registerer; +static FstRegisterer OutputRhoFst_Log64Arc_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/special/sigma-fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/special/sigma-fst.cc new file mode 100644 index 0000000000..30cd6a84ec --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/extensions/special/sigma-fst.cc @@ -0,0 +1,33 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +#include + +DEFINE_int64(sigma_fst_sigma_label, 0, + "Label of transitions to be interpreted as sigma ('any') " + "transitions"); +DEFINE_string(sigma_fst_rewrite_mode, "auto", + "Rewrite both sides when matching? One of:" + " \"auto\" (rewrite iff acceptor), \"always\", \"never\""); + +namespace fst { + +const char sigma_fst_type[] = "sigma"; +const char input_sigma_fst_type[] = "input_sigma"; +const char output_sigma_fst_type[] = "output_sigma"; + +static FstRegisterer SigmaFst_StdArc_registerer; +static FstRegisterer SigmaFst_LogArc_registerer; +static FstRegisterer SigmaFst_Log64Arc_registerer; + +static FstRegisterer InputSigmaFst_StdArc_registerer; +static FstRegisterer InputSigmaFst_LogArc_registerer; +static FstRegisterer InputSigmaFst_Log64Arc_registerer; + +static FstRegisterer OutputSigmaFst_StdArc_registerer; +static FstRegisterer OutputSigmaFst_LogArc_registerer; +static FstRegisterer OutputSigmaFst_Log64Arc_registerer; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/Makefile.am b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/Makefile.am new file mode 100644 index 0000000000..680933baa5 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/Makefile.am @@ -0,0 +1,130 @@ +if HAVE_COMPRESS +compress_include_headers = fst/extensions/compress/compress.h \ +fst/extensions/compress/compress-script.h fst/extensions/compress/gzfile.h \ +fst/extensions/compress/elias.h fst/extensions/compress/randmod.h +endif + +if HAVE_FAR +far_include_headers = fst/extensions/far/compile-strings.h \ +fst/extensions/far/create.h fst/extensions/far/equal.h \ +fst/extensions/far/extract.h fst/extensions/far/far.h \ +fst/extensions/far/far-class.h fst/extensions/far/farlib.h \ +fst/extensions/far/farscript.h fst/extensions/far/getters.h \ +fst/extensions/far/info.h fst/extensions/far/isomorphic.h \ +fst/extensions/far/print-strings.h fst/extensions/far/script-impl.h \ +fst/extensions/far/stlist.h fst/extensions/far/sttable.h +endif + +if HAVE_LINEAR +linear_include_headers = fst/extensions/linear/linear-fst-data-builder.h \ +fst/extensions/linear/linear-fst-data.h fst/extensions/linear/linear-fst.h \ +fst/extensions/linear/linearscript.h fst/extensions/linear/loglinear-apply.h \ +fst/extensions/linear/trie.h +endif + +if HAVE_MPDT +mpdt_include_headers = fst/extensions/mpdt/compose.h \ +fst/extensions/mpdt/expand.h fst/extensions/mpdt/info.h \ +fst/extensions/mpdt/mpdt.h fst/extensions/mpdt/mpdtlib.h \ +fst/extensions/mpdt/mpdtscript.h fst/extensions/mpdt/read_write_utils.h \ +fst/extensions/mpdt/reverse.h +endif + +if HAVE_NGRAM +ngram_include_headers = fst/extensions/ngram/bitmap-index.h \ +fst/extensions/ngram/ngram-fst.h fst/extensions/ngram/nthbit.h +endif + +if HAVE_PDT +pdt_include_headers = fst/extensions/pdt/collection.h \ +fst/extensions/pdt/compose.h fst/extensions/pdt/expand.h \ +fst/extensions/pdt/getters.h fst/extensions/pdt/info.h \ +fst/extensions/pdt/paren.h fst/extensions/pdt/pdt.h \ +fst/extensions/pdt/pdtlib.h fst/extensions/pdt/pdtscript.h \ +fst/extensions/pdt/replace.h fst/extensions/pdt/reverse.h \ +fst/extensions/pdt/shortest-path.h +endif + +if HAVE_SPECIAL +special_include_headers = fst/extensions/special/phi-fst.h \ +fst/extensions/special/rho-fst.h fst/extensions/special/sigma-fst.h +endif + +if HAVE_GRM +far_include_headers = fst/extensions/far/compile-strings.h \ +fst/extensions/far/create.h fst/extensions/far/equal.h \ +fst/extensions/far/extract.h fst/extensions/far/far.h \ +fst/extensions/far/far-class.h fst/extensions/far/farlib.h \ +fst/extensions/far/farscript.h fst/extensions/far/getters.h \ +fst/extensions/far/info.h fst/extensions/far/isomorphic.h \ +fst/extensions/far/print-strings.h fst/extensions/far/script-impl.h \ +fst/extensions/far/stlist.h fst/extensions/far/sttable.h +mpdt_include_headers = fst/extensions/mpdt/compose.h \ +fst/extensions/mpdt/expand.h fst/extensions/mpdt/info.h \ +fst/extensions/mpdt/mpdt.h fst/extensions/mpdt/mpdtlib.h \ +fst/extensions/mpdt/mpdtscript.h fst/extensions/mpdt/read_write_utils.h \ +fst/extensions/mpdt/reverse.h +pdt_include_headers = fst/extensions/pdt/collection.h \ +fst/extensions/pdt/compose.h fst/extensions/pdt/expand.h \ +fst/extensions/pdt/getters.h fst/extensions/pdt/info.h \ +fst/extensions/pdt/paren.h fst/extensions/pdt/pdt.h \ +fst/extensions/pdt/pdtlib.h fst/extensions/pdt/pdtscript.h \ +fst/extensions/pdt/replace.h fst/extensions/pdt/reverse.h \ +fst/extensions/pdt/shortest-path.h +endif + +script_include_headers = fst/script/arc-class.h \ +fst/script/arciterator-class.h fst/script/arcsort.h \ +fst/script/arg-packs.h fst/script/closure.h fst/script/compile-impl.h \ +fst/script/compile.h fst/script/compose.h fst/script/concat.h \ +fst/script/connect.h fst/script/convert.h fst/script/decode.h \ +fst/script/determinize.h fst/script/difference.h fst/script/disambiguate.h \ +fst/script/draw-impl.h fst/script/draw.h fst/script/encode.h \ +fst/script/encodemapper-class.h fst/script/epsnormalize.h fst/script/equal.h \ +fst/script/equivalent.h fst/script/fst-class.h fst/script/fstscript.h \ +fst/script/getters.h fst/script/info-impl.h fst/script/info.h \ +fst/script/intersect.h fst/script/invert.h fst/script/isomorphic.h \ +fst/script/map.h fst/script/minimize.h fst/script/print-impl.h \ +fst/script/print.h fst/script/project.h fst/script/prune.h \ +fst/script/push.h fst/script/randequivalent.h fst/script/randgen.h \ +fst/script/register.h fst/script/relabel.h fst/script/replace.h \ +fst/script/reverse.h fst/script/reweight.h fst/script/rmepsilon.h \ +fst/script/script-impl.h fst/script/shortest-distance.h \ +fst/script/shortest-path.h fst/script/stateiterator-class.h \ +fst/script/synchronize.h fst/script/text-io.h fst/script/topsort.h \ +fst/script/union.h fst/script/weight-class.h fst/script/fstscript-decl.h \ +fst/script/verify.h + +nobase_include_HEADERS = fst/accumulator.h fst/add-on.h fst/arc-arena.h \ +fst/arc-map.h fst/arc.h fst/arcfilter.h fst/arcsort.h fst/bi-table.h \ +fst/cache.h fst/closure.h fst/compact-fst.h fst/compat.h fst/complement.h \ +fst/compose-filter.h fst/compose.h fst/concat.h fst/config.h fst/connect.h \ +fst/const-fst.h fst/determinize.h fst/dfs-visit.h fst/difference.h \ +fst/disambiguate.h fst/edit-fst.h fst/encode.h fst/epsnormalize.h fst/equal.h \ +fst/equivalent.h fst/expanded-fst.h fst/expectation-weight.h \ +fst/factor-weight.h fst/filter-state.h fst/flags.h fst/float-weight.h \ +fst/fst-decl.h fst/fst.h fst/fstlib.h fst/generic-register.h fst/heap.h \ +fst/icu.h fst/intersect.h fst/interval-set.h fst/invert.h fst/isomorphic.h \ +fst/label-reachable.h fst/lexicographic-weight.h fst/lock.h fst/log.h \ +fst/lookahead-filter.h fst/lookahead-matcher.h fst/map.h fst/mapped-file.h \ +fst/matcher-fst.h fst/matcher.h fst/memory.h fst/minimize.h fst/mutable-fst.h \ +fst/pair-weight.h fst/partition.h fst/power-weight.h fst/product-weight.h \ +fst/project.h fst/properties.h fst/prune.h fst/push.h fst/queue.h \ +fst/randequivalent.h fst/randgen.h fst/rational.h fst/register.h \ +fst/relabel.h fst/replace-util.h fst/replace.h fst/reverse.h fst/reweight.h \ +fst/rmepsilon.h fst/rmfinalepsilon.h fst/set-weight.h fst/shortest-distance.h \ +fst/shortest-path.h fst/signed-log-weight.h fst/sparse-power-weight.h \ +fst/sparse-tuple-weight.h fst/state-map.h fst/state-reachable.h \ +fst/state-table.h fst/statesort.h fst/string-weight.h fst/string.h \ +fst/symbol-table-ops.h fst/symbol-table.h fst/synchronize.h \ +fst/test-properties.h fst/topsort.h fst/tuple-weight.h fst/types.h \ +fst/union-find.h fst/union-weight.h fst/union.h fst/util.h fst/vector-fst.h \ +fst/verify.h fst/visit.h fst/weight.h \ +$(compress_include_headers) \ +$(far_include_headers) \ +$(linear_include_headers) \ +$(mpdt_include_headers) \ +$(ngram_include_headers) \ +$(pdt_include_headers) \ +$(script_include_headers) \ +$(special_include_headers) diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/Makefile.in b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/Makefile.in new file mode 100644 index 0000000000..9b6133b4db --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/Makefile.in @@ -0,0 +1,778 @@ +# Makefile.in generated by automake 1.14.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2013 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +VPATH = @srcdir@ +am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +subdir = src/include +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ + $(am__nobase_include_HEADERS_DIST) +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \ + $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ + $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ + $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h \ + $(top_builddir)/src/include/fst/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +SOURCES = +DIST_SOURCES = +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__nobase_include_HEADERS_DIST = fst/accumulator.h fst/add-on.h \ + fst/arc-arena.h fst/arc-map.h fst/arc.h fst/arcfilter.h \ + fst/arcsort.h fst/bi-table.h fst/cache.h fst/closure.h \ + fst/compact-fst.h fst/compat.h fst/complement.h \ + fst/compose-filter.h fst/compose.h fst/concat.h fst/config.h \ + fst/connect.h fst/const-fst.h fst/determinize.h \ + fst/dfs-visit.h fst/difference.h fst/disambiguate.h \ + fst/edit-fst.h fst/encode.h fst/epsnormalize.h fst/equal.h \ + fst/equivalent.h fst/expanded-fst.h fst/expectation-weight.h \ + fst/factor-weight.h fst/filter-state.h fst/flags.h \ + fst/float-weight.h fst/fst-decl.h fst/fst.h fst/fstlib.h \ + fst/generic-register.h fst/heap.h fst/icu.h fst/intersect.h \ + fst/interval-set.h fst/invert.h fst/isomorphic.h \ + fst/label-reachable.h fst/lexicographic-weight.h fst/lock.h \ + fst/log.h fst/lookahead-filter.h fst/lookahead-matcher.h \ + fst/map.h fst/mapped-file.h fst/matcher-fst.h fst/matcher.h \ + fst/memory.h fst/minimize.h fst/mutable-fst.h \ + fst/pair-weight.h fst/partition.h fst/power-weight.h \ + fst/product-weight.h fst/project.h fst/properties.h \ + fst/prune.h fst/push.h fst/queue.h fst/randequivalent.h \ + fst/randgen.h fst/rational.h fst/register.h fst/relabel.h \ + fst/replace-util.h fst/replace.h fst/reverse.h fst/reweight.h \ + fst/rmepsilon.h fst/rmfinalepsilon.h fst/set-weight.h \ + fst/shortest-distance.h fst/shortest-path.h \ + fst/signed-log-weight.h fst/sparse-power-weight.h \ + fst/sparse-tuple-weight.h fst/state-map.h \ + fst/state-reachable.h fst/state-table.h fst/statesort.h \ + fst/string-weight.h fst/string.h fst/symbol-table-ops.h \ + fst/symbol-table.h fst/synchronize.h fst/test-properties.h \ + fst/topsort.h fst/tuple-weight.h fst/types.h fst/union-find.h \ + fst/union-weight.h fst/union.h fst/util.h fst/vector-fst.h \ + fst/verify.h fst/visit.h fst/weight.h \ + fst/extensions/compress/compress.h \ + fst/extensions/compress/compress-script.h \ + fst/extensions/compress/gzfile.h \ + fst/extensions/compress/elias.h \ + fst/extensions/compress/randmod.h \ + fst/extensions/far/compile-strings.h \ + fst/extensions/far/create.h fst/extensions/far/equal.h \ + fst/extensions/far/extract.h fst/extensions/far/far.h \ + fst/extensions/far/far-class.h fst/extensions/far/farlib.h \ + fst/extensions/far/farscript.h fst/extensions/far/getters.h \ + fst/extensions/far/info.h fst/extensions/far/isomorphic.h \ + fst/extensions/far/print-strings.h \ + fst/extensions/far/script-impl.h fst/extensions/far/stlist.h \ + fst/extensions/far/sttable.h \ + fst/extensions/linear/linear-fst-data-builder.h \ + fst/extensions/linear/linear-fst-data.h \ + fst/extensions/linear/linear-fst.h \ + fst/extensions/linear/linearscript.h \ + fst/extensions/linear/loglinear-apply.h \ + fst/extensions/linear/trie.h fst/extensions/mpdt/compose.h \ + fst/extensions/mpdt/expand.h fst/extensions/mpdt/info.h \ + fst/extensions/mpdt/mpdt.h fst/extensions/mpdt/mpdtlib.h \ + fst/extensions/mpdt/mpdtscript.h \ + fst/extensions/mpdt/read_write_utils.h \ + fst/extensions/mpdt/reverse.h \ + fst/extensions/ngram/bitmap-index.h \ + fst/extensions/ngram/ngram-fst.h fst/extensions/ngram/nthbit.h \ + fst/extensions/pdt/collection.h fst/extensions/pdt/compose.h \ + fst/extensions/pdt/expand.h fst/extensions/pdt/getters.h \ + fst/extensions/pdt/info.h fst/extensions/pdt/paren.h \ + fst/extensions/pdt/pdt.h fst/extensions/pdt/pdtlib.h \ + fst/extensions/pdt/pdtscript.h fst/extensions/pdt/replace.h \ + fst/extensions/pdt/reverse.h \ + fst/extensions/pdt/shortest-path.h fst/script/arc-class.h \ + fst/script/arciterator-class.h fst/script/arcsort.h \ + fst/script/arg-packs.h fst/script/closure.h \ + fst/script/compile-impl.h fst/script/compile.h \ + fst/script/compose.h fst/script/concat.h fst/script/connect.h \ + fst/script/convert.h fst/script/decode.h \ + fst/script/determinize.h fst/script/difference.h \ + fst/script/disambiguate.h fst/script/draw-impl.h \ + fst/script/draw.h fst/script/encode.h \ + fst/script/encodemapper-class.h fst/script/epsnormalize.h \ + fst/script/equal.h fst/script/equivalent.h \ + fst/script/fst-class.h fst/script/fstscript.h \ + fst/script/getters.h fst/script/info-impl.h fst/script/info.h \ + fst/script/intersect.h fst/script/invert.h \ + fst/script/isomorphic.h fst/script/map.h fst/script/minimize.h \ + fst/script/print-impl.h fst/script/print.h \ + fst/script/project.h fst/script/prune.h fst/script/push.h \ + fst/script/randequivalent.h fst/script/randgen.h \ + fst/script/register.h fst/script/relabel.h \ + fst/script/replace.h fst/script/reverse.h \ + fst/script/reweight.h fst/script/rmepsilon.h \ + fst/script/script-impl.h fst/script/shortest-distance.h \ + fst/script/shortest-path.h fst/script/stateiterator-class.h \ + fst/script/synchronize.h fst/script/text-io.h \ + fst/script/topsort.h fst/script/union.h \ + fst/script/weight-class.h fst/script/fstscript-decl.h \ + fst/script/verify.h fst/extensions/special/phi-fst.h \ + fst/extensions/special/rho-fst.h \ + fst/extensions/special/sigma-fst.h +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__uninstall_files_from_dir = { \ + test -z "$$files" \ + || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && rm -f $$files; }; \ + } +am__installdirs = "$(DESTDIR)$(includedir)" +HEADERS = $(nobase_include_HEADERS) +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DL_LIBS = @DL_LIBS@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PYTHON = @PYTHON@ +PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@ +PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ +PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@ +PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@ +PYTHON_LDFLAGS = @PYTHON_LDFLAGS@ +PYTHON_PLATFORM = @PYTHON_PLATFORM@ +PYTHON_PREFIX = @PYTHON_PREFIX@ +PYTHON_SITE_PKG = @PYTHON_SITE_PKG@ +PYTHON_VERSION = @PYTHON_VERSION@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +libfstdir = @libfstdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgpyexecdir = @pkgpyexecdir@ +pkgpythondir = @pkgpythondir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +pyexecdir = @pyexecdir@ +pythondir = @pythondir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +@HAVE_COMPRESS_TRUE@compress_include_headers = fst/extensions/compress/compress.h \ +@HAVE_COMPRESS_TRUE@fst/extensions/compress/compress-script.h fst/extensions/compress/gzfile.h \ +@HAVE_COMPRESS_TRUE@fst/extensions/compress/elias.h fst/extensions/compress/randmod.h + +@HAVE_FAR_TRUE@far_include_headers = fst/extensions/far/compile-strings.h \ +@HAVE_FAR_TRUE@fst/extensions/far/create.h fst/extensions/far/equal.h \ +@HAVE_FAR_TRUE@fst/extensions/far/extract.h fst/extensions/far/far.h \ +@HAVE_FAR_TRUE@fst/extensions/far/far-class.h fst/extensions/far/farlib.h \ +@HAVE_FAR_TRUE@fst/extensions/far/farscript.h fst/extensions/far/getters.h \ +@HAVE_FAR_TRUE@fst/extensions/far/info.h fst/extensions/far/isomorphic.h \ +@HAVE_FAR_TRUE@fst/extensions/far/print-strings.h fst/extensions/far/script-impl.h \ +@HAVE_FAR_TRUE@fst/extensions/far/stlist.h fst/extensions/far/sttable.h + +@HAVE_GRM_TRUE@far_include_headers = fst/extensions/far/compile-strings.h \ +@HAVE_GRM_TRUE@fst/extensions/far/create.h fst/extensions/far/equal.h \ +@HAVE_GRM_TRUE@fst/extensions/far/extract.h fst/extensions/far/far.h \ +@HAVE_GRM_TRUE@fst/extensions/far/far-class.h fst/extensions/far/farlib.h \ +@HAVE_GRM_TRUE@fst/extensions/far/farscript.h fst/extensions/far/getters.h \ +@HAVE_GRM_TRUE@fst/extensions/far/info.h fst/extensions/far/isomorphic.h \ +@HAVE_GRM_TRUE@fst/extensions/far/print-strings.h fst/extensions/far/script-impl.h \ +@HAVE_GRM_TRUE@fst/extensions/far/stlist.h fst/extensions/far/sttable.h + +@HAVE_LINEAR_TRUE@linear_include_headers = fst/extensions/linear/linear-fst-data-builder.h \ +@HAVE_LINEAR_TRUE@fst/extensions/linear/linear-fst-data.h fst/extensions/linear/linear-fst.h \ +@HAVE_LINEAR_TRUE@fst/extensions/linear/linearscript.h fst/extensions/linear/loglinear-apply.h \ +@HAVE_LINEAR_TRUE@fst/extensions/linear/trie.h + +@HAVE_GRM_TRUE@mpdt_include_headers = fst/extensions/mpdt/compose.h \ +@HAVE_GRM_TRUE@fst/extensions/mpdt/expand.h fst/extensions/mpdt/info.h \ +@HAVE_GRM_TRUE@fst/extensions/mpdt/mpdt.h fst/extensions/mpdt/mpdtlib.h \ +@HAVE_GRM_TRUE@fst/extensions/mpdt/mpdtscript.h fst/extensions/mpdt/read_write_utils.h \ +@HAVE_GRM_TRUE@fst/extensions/mpdt/reverse.h + +@HAVE_MPDT_TRUE@mpdt_include_headers = fst/extensions/mpdt/compose.h \ +@HAVE_MPDT_TRUE@fst/extensions/mpdt/expand.h fst/extensions/mpdt/info.h \ +@HAVE_MPDT_TRUE@fst/extensions/mpdt/mpdt.h fst/extensions/mpdt/mpdtlib.h \ +@HAVE_MPDT_TRUE@fst/extensions/mpdt/mpdtscript.h fst/extensions/mpdt/read_write_utils.h \ +@HAVE_MPDT_TRUE@fst/extensions/mpdt/reverse.h + +@HAVE_NGRAM_TRUE@ngram_include_headers = fst/extensions/ngram/bitmap-index.h \ +@HAVE_NGRAM_TRUE@fst/extensions/ngram/ngram-fst.h fst/extensions/ngram/nthbit.h + +@HAVE_GRM_TRUE@pdt_include_headers = fst/extensions/pdt/collection.h \ +@HAVE_GRM_TRUE@fst/extensions/pdt/compose.h fst/extensions/pdt/expand.h \ +@HAVE_GRM_TRUE@fst/extensions/pdt/getters.h fst/extensions/pdt/info.h \ +@HAVE_GRM_TRUE@fst/extensions/pdt/paren.h fst/extensions/pdt/pdt.h \ +@HAVE_GRM_TRUE@fst/extensions/pdt/pdtlib.h fst/extensions/pdt/pdtscript.h \ +@HAVE_GRM_TRUE@fst/extensions/pdt/replace.h fst/extensions/pdt/reverse.h \ +@HAVE_GRM_TRUE@fst/extensions/pdt/shortest-path.h + +@HAVE_PDT_TRUE@pdt_include_headers = fst/extensions/pdt/collection.h \ +@HAVE_PDT_TRUE@fst/extensions/pdt/compose.h fst/extensions/pdt/expand.h \ +@HAVE_PDT_TRUE@fst/extensions/pdt/getters.h fst/extensions/pdt/info.h \ +@HAVE_PDT_TRUE@fst/extensions/pdt/paren.h fst/extensions/pdt/pdt.h \ +@HAVE_PDT_TRUE@fst/extensions/pdt/pdtlib.h fst/extensions/pdt/pdtscript.h \ +@HAVE_PDT_TRUE@fst/extensions/pdt/replace.h fst/extensions/pdt/reverse.h \ +@HAVE_PDT_TRUE@fst/extensions/pdt/shortest-path.h + +@HAVE_SPECIAL_TRUE@special_include_headers = fst/extensions/special/phi-fst.h \ +@HAVE_SPECIAL_TRUE@fst/extensions/special/rho-fst.h fst/extensions/special/sigma-fst.h + +script_include_headers = fst/script/arc-class.h \ +fst/script/arciterator-class.h fst/script/arcsort.h \ +fst/script/arg-packs.h fst/script/closure.h fst/script/compile-impl.h \ +fst/script/compile.h fst/script/compose.h fst/script/concat.h \ +fst/script/connect.h fst/script/convert.h fst/script/decode.h \ +fst/script/determinize.h fst/script/difference.h fst/script/disambiguate.h \ +fst/script/draw-impl.h fst/script/draw.h fst/script/encode.h \ +fst/script/encodemapper-class.h fst/script/epsnormalize.h fst/script/equal.h \ +fst/script/equivalent.h fst/script/fst-class.h fst/script/fstscript.h \ +fst/script/getters.h fst/script/info-impl.h fst/script/info.h \ +fst/script/intersect.h fst/script/invert.h fst/script/isomorphic.h \ +fst/script/map.h fst/script/minimize.h fst/script/print-impl.h \ +fst/script/print.h fst/script/project.h fst/script/prune.h \ +fst/script/push.h fst/script/randequivalent.h fst/script/randgen.h \ +fst/script/register.h fst/script/relabel.h fst/script/replace.h \ +fst/script/reverse.h fst/script/reweight.h fst/script/rmepsilon.h \ +fst/script/script-impl.h fst/script/shortest-distance.h \ +fst/script/shortest-path.h fst/script/stateiterator-class.h \ +fst/script/synchronize.h fst/script/text-io.h fst/script/topsort.h \ +fst/script/union.h fst/script/weight-class.h fst/script/fstscript-decl.h \ +fst/script/verify.h + +nobase_include_HEADERS = fst/accumulator.h fst/add-on.h fst/arc-arena.h \ +fst/arc-map.h fst/arc.h fst/arcfilter.h fst/arcsort.h fst/bi-table.h \ +fst/cache.h fst/closure.h fst/compact-fst.h fst/compat.h fst/complement.h \ +fst/compose-filter.h fst/compose.h fst/concat.h fst/config.h fst/connect.h \ +fst/const-fst.h fst/determinize.h fst/dfs-visit.h fst/difference.h \ +fst/disambiguate.h fst/edit-fst.h fst/encode.h fst/epsnormalize.h fst/equal.h \ +fst/equivalent.h fst/expanded-fst.h fst/expectation-weight.h \ +fst/factor-weight.h fst/filter-state.h fst/flags.h fst/float-weight.h \ +fst/fst-decl.h fst/fst.h fst/fstlib.h fst/generic-register.h fst/heap.h \ +fst/icu.h fst/intersect.h fst/interval-set.h fst/invert.h fst/isomorphic.h \ +fst/label-reachable.h fst/lexicographic-weight.h fst/lock.h fst/log.h \ +fst/lookahead-filter.h fst/lookahead-matcher.h fst/map.h fst/mapped-file.h \ +fst/matcher-fst.h fst/matcher.h fst/memory.h fst/minimize.h fst/mutable-fst.h \ +fst/pair-weight.h fst/partition.h fst/power-weight.h fst/product-weight.h \ +fst/project.h fst/properties.h fst/prune.h fst/push.h fst/queue.h \ +fst/randequivalent.h fst/randgen.h fst/rational.h fst/register.h \ +fst/relabel.h fst/replace-util.h fst/replace.h fst/reverse.h fst/reweight.h \ +fst/rmepsilon.h fst/rmfinalepsilon.h fst/set-weight.h fst/shortest-distance.h \ +fst/shortest-path.h fst/signed-log-weight.h fst/sparse-power-weight.h \ +fst/sparse-tuple-weight.h fst/state-map.h fst/state-reachable.h \ +fst/state-table.h fst/statesort.h fst/string-weight.h fst/string.h \ +fst/symbol-table-ops.h fst/symbol-table.h fst/synchronize.h \ +fst/test-properties.h fst/topsort.h fst/tuple-weight.h fst/types.h \ +fst/union-find.h fst/union-weight.h fst/union.h fst/util.h fst/vector-fst.h \ +fst/verify.h fst/visit.h fst/weight.h \ +$(compress_include_headers) \ +$(far_include_headers) \ +$(linear_include_headers) \ +$(mpdt_include_headers) \ +$(ngram_include_headers) \ +$(pdt_include_headers) \ +$(script_include_headers) \ +$(special_include_headers) + +all: all-am + +.SUFFIXES: +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/include/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign src/include/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs +install-nobase_includeHEADERS: $(nobase_include_HEADERS) + @$(NORMAL_INSTALL) + @list='$(nobase_include_HEADERS)'; test -n "$(includedir)" || list=; \ + if test -n "$$list"; then \ + echo " $(MKDIR_P) '$(DESTDIR)$(includedir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(includedir)" || exit 1; \ + fi; \ + $(am__nobase_list) | while read dir files; do \ + xfiles=; for file in $$files; do \ + if test -f "$$file"; then xfiles="$$xfiles $$file"; \ + else xfiles="$$xfiles $(srcdir)/$$file"; fi; done; \ + test -z "$$xfiles" || { \ + test "x$$dir" = x. || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(includedir)/$$dir'"; \ + $(MKDIR_P) "$(DESTDIR)$(includedir)/$$dir"; }; \ + echo " $(INSTALL_HEADER) $$xfiles '$(DESTDIR)$(includedir)/$$dir'"; \ + $(INSTALL_HEADER) $$xfiles "$(DESTDIR)$(includedir)/$$dir" || exit $$?; }; \ + done + +uninstall-nobase_includeHEADERS: + @$(NORMAL_UNINSTALL) + @list='$(nobase_include_HEADERS)'; test -n "$(includedir)" || list=; \ + $(am__nobase_strip_setup); files=`$(am__nobase_strip)`; \ + dir='$(DESTDIR)$(includedir)'; $(am__uninstall_files_from_dir) + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-am +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-am + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscopelist: cscopelist-am + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(HEADERS) +installdirs: + for dir in "$(DESTDIR)$(includedir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic clean-libtool mostlyclean-am + +distclean: distclean-am + -rm -f Makefile +distclean-am: clean-am distclean-generic distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: install-nobase_includeHEADERS + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-generic mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-nobase_includeHEADERS + +.MAKE: install-am install-strip + +.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \ + clean-libtool cscopelist-am ctags ctags-am distclean \ + distclean-generic distclean-libtool distclean-tags distdir dvi \ + dvi-am html html-am info info-am install install-am \ + install-data install-data-am install-dvi install-dvi-am \ + install-exec install-exec-am install-html install-html-am \ + install-info install-info-am install-man \ + install-nobase_includeHEADERS install-pdf install-pdf-am \ + install-ps install-ps-am install-strip installcheck \ + installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-generic \ + mostlyclean-libtool pdf pdf-am ps ps-am tags tags-am uninstall \ + uninstall-am uninstall-nobase_includeHEADERS + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/accumulator.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/accumulator.h new file mode 100644 index 0000000000..eb0f34920f --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/accumulator.h @@ -0,0 +1,903 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Classes to accumulate arc weights. Useful for weight lookahead. + +#ifndef FST_ACCUMULATOR_H_ +#define FST_ACCUMULATOR_H_ + +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include + +namespace fst { + +// This class accumulates arc weights using the semiring Plus(). +template +class DefaultAccumulator { + public: + using Arc = A; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + DefaultAccumulator() {} + + DefaultAccumulator(const DefaultAccumulator &acc, bool safe = false) {} + + void Init(const Fst &fst, bool copy = false) {} + + void SetState(StateId state) {} + + Weight Sum(Weight w, Weight v) { return Plus(w, v); } + + template + Weight Sum(Weight w, ArcIter *aiter, ssize_t begin, ssize_t end) { + Adder adder(w); // maintains cumulative sum accurately + aiter->Seek(begin); + for (auto pos = begin; pos < end; aiter->Next(), ++pos) + adder.Add(aiter->Value().weight); + return adder.Sum(); + } + + constexpr bool Error() const { return false; } + + private: + DefaultAccumulator &operator=(const DefaultAccumulator &) = delete; +}; + +// This class accumulates arc weights using the log semiring Plus() assuming an +// arc weight has a WeightConvert specialization to and from log64 weights. +template +class LogAccumulator { + public: + using Arc = A; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + LogAccumulator() {} + + LogAccumulator(const LogAccumulator &acc, bool safe = false) {} + + void Init(const Fst &fst, bool copy = false) {} + + void SetState(StateId s) {} + + Weight Sum(Weight w, Weight v) { return LogPlus(w, v); } + + template + Weight Sum(Weight w, ArcIter *aiter, ssize_t begin, ssize_t end) { + auto sum = w; + aiter->Seek(begin); + for (auto pos = begin; pos < end; aiter->Next(), ++pos) { + sum = LogPlus(sum, aiter->Value().weight); + } + return sum; + } + + constexpr bool Error() const { return false; } + + private: + Weight LogPlus(Weight w, Weight v) { + if (w == Weight::Zero()) { + return v; + } + const auto f1 = to_log_weight_(w).Value(); + const auto f2 = to_log_weight_(v).Value(); + if (f1 > f2) { + return to_weight_(Log64Weight(f2 - internal::LogPosExp(f1 - f2))); + } else { + return to_weight_(Log64Weight(f1 - internal::LogPosExp(f2 - f1))); + } + } + + WeightConvert to_log_weight_; + WeightConvert to_weight_; + + LogAccumulator &operator=(const LogAccumulator &) = delete; +}; + +// Interface for shareable data for fast log accumulator copies. Holds pointers +// to data only, storage is provided by derived classes. +class FastLogAccumulatorData { + public: + FastLogAccumulatorData(int arc_limit, int arc_period) + : arc_limit_(arc_limit), + arc_period_(arc_period), + weights_ptr_(nullptr), + num_weights_(0), + weight_positions_ptr_(nullptr), + num_positions_(0) {} + + virtual ~FastLogAccumulatorData() {} + + // Cummulative weight per state for all states s.t. # of arcs > arc_limit_ + // with arcs in order. The first element per state is Log64Weight::Zero(). + const double *Weights() const { return weights_ptr_; } + + int NumWeights() const { return num_weights_; } + + // Maps from state to corresponding beginning weight position in weights_. + // osition -1 means no pre-computed weights for that state. + const int *WeightPositions() const { return weight_positions_ptr_; } + + int NumPositions() const { return num_positions_; } + + int ArcLimit() const { return arc_limit_; } + + int ArcPeriod() const { return arc_period_; } + + // Returns true if the data object is mutable and supports SetData(). + virtual bool IsMutable() const = 0; + + // Does not take ownership but may invalidate the contents of weights and + // weight_positions. + virtual void SetData(std::vector *weights, + std::vector *weight_positions) = 0; + + protected: + void Init(int num_weights, const double *weights, int num_positions, + const int *weight_positions) { + weights_ptr_ = weights; + num_weights_ = num_weights; + weight_positions_ptr_ = weight_positions; + num_positions_ = num_positions; + } + + private: + const int arc_limit_; + const int arc_period_; + const double *weights_ptr_; + int num_weights_; + const int *weight_positions_ptr_; + int num_positions_; + + FastLogAccumulatorData(const FastLogAccumulatorData &) = delete; + FastLogAccumulatorData &operator=(const FastLogAccumulatorData &) = delete; +}; + +// FastLogAccumulatorData with mutable storage; filled by +// FastLogAccumulator::Init. +class MutableFastLogAccumulatorData : public FastLogAccumulatorData { + public: + MutableFastLogAccumulatorData(int arc_limit, int arc_period) + : FastLogAccumulatorData(arc_limit, arc_period) {} + + bool IsMutable() const override { return true; } + + void SetData(std::vector *weights, + std::vector *weight_positions) override { + weights_.swap(*weights); + weight_positions_.swap(*weight_positions); + Init(weights_.size(), weights_.data(), weight_positions_.size(), + weight_positions_.data()); + } + + private: + std::vector weights_; + std::vector weight_positions_; + + MutableFastLogAccumulatorData(const MutableFastLogAccumulatorData &) = delete; + MutableFastLogAccumulatorData &operator=( + const MutableFastLogAccumulatorData &) = delete; +}; + +// This class accumulates arc weights using the log semiring Plus() assuming an +// arc weight has a WeightConvert specialization to and from log64 weights. The +// member function Init(fst) has to be called to setup pre-computed weight +// information. +template +class FastLogAccumulator { + public: + using Arc = A; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + explicit FastLogAccumulator(ssize_t arc_limit = 20, ssize_t arc_period = 10) + : to_log_weight_(), + to_weight_(), + arc_limit_(arc_limit), + arc_period_(arc_period), + data_(std::make_shared(arc_limit, + arc_period)), + state_weights_(nullptr), + error_(false) {} + + explicit FastLogAccumulator(std::shared_ptr data) + : to_log_weight_(), + to_weight_(), + arc_limit_(data->ArcLimit()), + arc_period_(data->ArcPeriod()), + data_(data), + state_weights_(nullptr), + error_(false) {} + + FastLogAccumulator(const FastLogAccumulator &acc, bool safe = false) + : to_log_weight_(), + to_weight_(), + arc_limit_(acc.arc_limit_), + arc_period_(acc.arc_period_), + data_(acc.data_), + state_weights_(nullptr), + error_(acc.error_) {} + + void SetState(StateId s) { + const auto *weights = data_->Weights(); + const auto *weight_positions = data_->WeightPositions(); + state_weights_ = nullptr; + if (s < data_->NumPositions()) { + const auto pos = weight_positions[s]; + if (pos >= 0) state_weights_ = &(weights[pos]); + } + } + + Weight Sum(Weight w, Weight v) const { return LogPlus(w, v); } + + template + Weight Sum(Weight w, ArcIter *aiter, ssize_t begin, ssize_t end) const { + if (error_) return Weight::NoWeight(); + auto sum = w; + // Finds begin and end of pre-stored weights. + ssize_t index_begin = -1; + ssize_t index_end = -1; + ssize_t stored_begin = end; + ssize_t stored_end = end; + if (state_weights_) { + index_begin = begin > 0 ? (begin - 1) / arc_period_ + 1 : 0; + index_end = end / arc_period_; + stored_begin = index_begin * arc_period_; + stored_end = index_end * arc_period_; + } + // Computes sum before pre-stored weights. + if (begin < stored_begin) { + const auto pos_end = std::min(stored_begin, end); + aiter->Seek(begin); + for (auto pos = begin; pos < pos_end; aiter->Next(), ++pos) { + sum = LogPlus(sum, aiter->Value().weight); + } + } + // Computes sum between pre-stored weights. + if (stored_begin < stored_end) { + const auto f1 = state_weights_[index_end]; + const auto f2 = state_weights_[index_begin]; + if (f1 < f2) sum = LogPlus(sum, LogMinus(f1, f2)); + // Commented out for efficiency; adds Zero(). + /* + else { + // explicitly computes if cumulative sum lacks precision + aiter->Seek(stored_begin); + for (auto pos = stored_begin; pos < stored_end; aiter->Next(), ++pos) + sum = LogPlus(sum, aiter->Value().weight); + } + */ + } + // Computes sum after pre-stored weights. + if (stored_end < end) { + const auto pos_start = std::max(stored_begin, stored_end); + aiter->Seek(pos_start); + for (auto pos = pos_start; pos < end; aiter->Next(), ++pos) { + sum = LogPlus(sum, aiter->Value().weight); + } + } + return sum; + } + + template + void Init(const FST &fst, bool copy = false) { + if (copy || !data_->IsMutable()) return; + if (data_->NumPositions() != 0 || arc_limit_ < arc_period_) { + FSTERROR() << "FastLogAccumulator: Initialization error"; + error_ = true; + return; + } + std::vector weights; + std::vector weight_positions; + weight_positions.reserve(CountStates(fst)); + for (StateIterator siter(fst); !siter.Done(); siter.Next()) { + const auto s = siter.Value(); + if (fst.NumArcs(s) >= arc_limit_) { + auto sum = FloatLimits::PosInfinity(); + if (weight_positions.size() <= s) weight_positions.resize(s + 1, -1); + weight_positions[s] = weights.size(); + weights.push_back(sum); + size_t narcs = 0; + ArcIterator aiter(fst, s); + aiter.SetFlags(kArcWeightValue | kArcNoCache, kArcFlags); + for (; !aiter.Done(); aiter.Next()) { + const auto &arc = aiter.Value(); + sum = LogPlus(sum, arc.weight); + // Stores cumulative weight distribution per arc_period_. + if (++narcs % arc_period_ == 0) weights.push_back(sum); + } + } + } + data_->SetData(&weights, &weight_positions); + } + + bool Error() const { return error_; } + + std::shared_ptr GetData() const { return data_; } + + private: + static double LogPosExp(double x) { + return x == FloatLimits::PosInfinity() ? 0.0 + : log(1.0F + exp(-x)); + } + + static double LogMinusExp(double x) { + return x == FloatLimits::PosInfinity() ? 0.0 + : log(1.0F - exp(-x)); + } + + Weight LogPlus(Weight w, Weight v) const { + if (w == Weight::Zero()) { + return v; + } + const auto f1 = to_log_weight_(w).Value(); + const auto f2 = to_log_weight_(v).Value(); + if (f1 > f2) { + return to_weight_(Log64Weight(f2 - LogPosExp(f1 - f2))); + } else { + return to_weight_(Log64Weight(f1 - LogPosExp(f2 - f1))); + } + } + + double LogPlus(double f1, Weight v) const { + const auto f2 = to_log_weight_(v).Value(); + if (f1 == FloatLimits::PosInfinity()) { + return f2; + } else if (f1 > f2) { + return f2 - LogPosExp(f1 - f2); + } else { + return f1 - LogPosExp(f2 - f1); + } + } + + // Assumes f1 < f2. + Weight LogMinus(double f1, double f2) const { + if (f2 == FloatLimits::PosInfinity()) { + return to_weight_(Log64Weight(f1)); + } else { + return to_weight_(Log64Weight(f1 - LogMinusExp(f2 - f1))); + } + } + + const WeightConvert to_log_weight_; + const WeightConvert to_weight_; + const ssize_t arc_limit_; // Minimum number of arcs to pre-compute state. + const ssize_t arc_period_; // Saves cumulative weights per arc_period_. + std::shared_ptr data_; + const double *state_weights_; + bool error_; + + FastLogAccumulator &operator=(const FastLogAccumulator &) = delete; +}; + +// Stores shareable data for cache log accumulator copies. All copies share the +// same cache. +template +class CacheLogAccumulatorData { + public: + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + CacheLogAccumulatorData(bool gc, size_t gc_limit) + : cache_gc_(gc), cache_limit_(gc_limit), cache_size_(0) {} + + CacheLogAccumulatorData(const CacheLogAccumulatorData &data) + : cache_gc_(data.cache_gc_), + cache_limit_(data.cache_limit_), + cache_size_(0) {} + + bool CacheDisabled() const { return cache_gc_ && cache_limit_ == 0; } + + std::vector *GetWeights(StateId s) { + auto it = cache_.find(s); + if (it != cache_.end()) { + it->second.recent = true; + return it->second.weights.get(); + } else { + return nullptr; + } + } + + void AddWeights(StateId s, std::vector *weights) { + if (cache_gc_ && cache_size_ >= cache_limit_) GC(false); + cache_.insert(std::make_pair(s, CacheState(weights, true))); + if (cache_gc_) cache_size_ += weights->capacity() * sizeof(double); + } + + private: + // Cached information for a given state. + struct CacheState { + std::unique_ptr> weights; // Accumulated weights. + bool recent; // Has this state been accessed since last GC? + + CacheState(std::vector *weights, bool recent) + : weights(weights), recent(recent) {} + }; + + // Garbage collect: Deletes from cache states that have not been accessed + // since the last GC ('free_recent = false') until 'cache_size_' is 2/3 of + // 'cache_limit_'. If it does not free enough memory, start deleting + // recently accessed states. + void GC(bool free_recent) { + auto cache_target = (2 * cache_limit_) / 3 + 1; + auto it = cache_.begin(); + while (it != cache_.end() && cache_size_ > cache_target) { + auto &cs = it->second; + if (free_recent || !cs.recent) { + cache_size_ -= cs.weights->capacity() * sizeof(double); + cache_.erase(it++); + } else { + cs.recent = false; + ++it; + } + } + if (!free_recent && cache_size_ > cache_target) GC(true); + } + + std::unordered_map cache_; // Cache. + bool cache_gc_; // Enables garbage collection. + size_t cache_limit_; // # of bytes cached. + size_t cache_size_; // # of bytes allowed before GC. + + CacheLogAccumulatorData &operator=(const CacheLogAccumulatorData &) = delete; +}; + +// This class accumulates arc weights using the log semiring Plus() has a +// WeightConvert specialization to and from log64 weights. It is similar to the +// FastLogAccumator. However here, the accumulated weights are pre-computed and +// stored only for the states that are visited. The member function Init(fst) +// has to be called to setup this accumulator. +template +class CacheLogAccumulator { + public: + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + explicit CacheLogAccumulator(ssize_t arc_limit = 10, bool gc = false, + size_t gc_limit = 10 * 1024 * 1024) + : arc_limit_(arc_limit), + data_(std::make_shared>(gc, gc_limit)), + s_(kNoStateId), + error_(false) {} + + CacheLogAccumulator(const CacheLogAccumulator &acc, bool safe = false) + : arc_limit_(acc.arc_limit_), + fst_(acc.fst_ ? acc.fst_->Copy() : nullptr), + data_(safe ? std::make_shared>(*acc.data_) + : acc.data_), + s_(kNoStateId), + error_(acc.error_) {} + + // Argument arc_limit specifies the minimum number of arcs to pre-compute. + void Init(const Fst &fst, bool copy = false) { + if (!copy && fst_) { + FSTERROR() << "CacheLogAccumulator: Initialization error"; + error_ = true; + return; + } + fst_.reset(fst.Copy()); + } + + void SetState(StateId s, int depth = 0) { + if (s == s_) return; + s_ = s; + if (data_->CacheDisabled() || error_) { + weights_ = nullptr; + return; + } + if (!fst_) { + FSTERROR() << "CacheLogAccumulator::SetState: Incorrectly initialized"; + error_ = true; + weights_ = nullptr; + return; + } + weights_ = data_->GetWeights(s); + if ((weights_ == nullptr) && (fst_->NumArcs(s) >= arc_limit_)) { + weights_ = new std::vector; + weights_->reserve(fst_->NumArcs(s) + 1); + weights_->push_back(FloatLimits::PosInfinity()); + data_->AddWeights(s, weights_); + } + } + + Weight Sum(Weight w, Weight v) { return LogPlus(w, v); } + + template + Weight Sum(Weight w, ArcIter *aiter, ssize_t begin, ssize_t end) { + if (weights_ == nullptr) { + auto sum = w; + aiter->Seek(begin); + for (auto pos = begin; pos < end; aiter->Next(), ++pos) { + sum = LogPlus(sum, aiter->Value().weight); + } + return sum; + } else { + Extend(end, aiter); + const auto &f1 = (*weights_)[end]; + const auto &f2 = (*weights_)[begin]; + if (f1 < f2) { + return LogPlus(w, LogMinus(f1, f2)); + } else { + // Commented out for efficiency; adds Zero(). + /* + auto sum = w; + // Explicitly computes if cumulative sum lacks precision. + aiter->Seek(begin); + for (auto pos = begin; pos < end; aiter->Next(), ++pos) { + sum = LogPlus(sum, aiter->Value().weight); + } + return sum; + */ + return w; + } + } + } + + // Returns first position from aiter->Position() whose accumulated + // value is greater or equal to w (w.r.t. Zero() < One()). The + // iterator may be repositioned. + template + size_t LowerBound(Weight w, ArcIter *aiter) { + const auto f = to_log_weight_(w).Value(); + auto pos = aiter->Position(); + if (weights_) { + Extend(fst_->NumArcs(s_), aiter); + return std::lower_bound(weights_->begin() + pos + 1, weights_->end(), + f, std::greater()) - + weights_->begin() - 1; + } else { + size_t n = 0; + auto x = FloatLimits::PosInfinity(); + for (aiter->Reset(); !aiter->Done(); aiter->Next(), ++n) { + x = LogPlus(x, aiter->Value().weight); + if (n >= pos && x <= f) break; + } + return n; + } + } + + bool Error() const { return error_; } + + private: + double LogPosExp(double x) { + return x == FloatLimits::PosInfinity() ? 0.0 + : log(1.0F + exp(-x)); + } + + double LogMinusExp(double x) { + return x == FloatLimits::PosInfinity() ? 0.0 + : log(1.0F - exp(-x)); + } + + Weight LogPlus(Weight w, Weight v) { + if (w == Weight::Zero()) { + return v; + } + const auto f1 = to_log_weight_(w).Value(); + const auto f2 = to_log_weight_(v).Value(); + if (f1 > f2) { + return to_weight_(Log64Weight(f2 - LogPosExp(f1 - f2))); + } else { + return to_weight_(Log64Weight(f1 - LogPosExp(f2 - f1))); + } + } + + double LogPlus(double f1, Weight v) { + const auto f2 = to_log_weight_(v).Value(); + if (f1 == FloatLimits::PosInfinity()) { + return f2; + } else if (f1 > f2) { + return f2 - LogPosExp(f1 - f2); + } else { + return f1 - LogPosExp(f2 - f1); + } + } + + // Assumes f1 < f2. + Weight LogMinus(double f1, double f2) { + if (f2 == FloatLimits::PosInfinity()) { + return to_weight_(Log64Weight(f1)); + } else { + return to_weight_(Log64Weight(f1 - LogMinusExp(f2 - f1))); + } + } + + // Extends weights up to index 'end'. + template + void Extend(ssize_t end, ArcIter *aiter) { + if (weights_->size() <= end) { + for (aiter->Seek(weights_->size() - 1); weights_->size() <= end; + aiter->Next()) { + weights_->push_back(LogPlus(weights_->back(), aiter->Value().weight)); + } + } + } + + + WeightConvert to_log_weight_; + WeightConvert to_weight_; + ssize_t arc_limit_; // Minimum # of arcs to cache a state. + std::vector *weights_; // Accumulated weights for cur. state. + std::unique_ptr> fst_; // Input FST. + std::shared_ptr> data_; // Cache data. + StateId s_; // Current state. + bool error_; +}; + +// Stores shareable data for replace accumulator copies. +template +class ReplaceAccumulatorData { + public: + using Arc = typename Accumulator::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using StateTable = T; + using StateTuple = typename StateTable::StateTuple; + + ReplaceAccumulatorData() : state_table_(nullptr) {} + + explicit ReplaceAccumulatorData( + const std::vector &accumulators) + : state_table_(nullptr) { + accumulators_.reserve(accumulators.size()); + for (const auto accumulator : accumulators) { + accumulators_.emplace_back(accumulator); + } + } + + void Init(const std::vector *>> &fst_tuples, + const StateTable *state_table) { + state_table_ = state_table; + accumulators_.resize(fst_tuples.size()); + for (Label i = 0; i < accumulators_.size(); ++i) { + if (!accumulators_[i]) { + accumulators_[i].reset(new Accumulator()); + accumulators_[i]->Init(*(fst_tuples[i].second)); + } + fst_array_.emplace_back(fst_tuples[i].second->Copy()); + } + } + + const StateTuple &GetTuple(StateId s) const { return state_table_->Tuple(s); } + + Accumulator *GetAccumulator(size_t i) { return accumulators_[i].get(); } + + const Fst *GetFst(size_t i) const { return fst_array_[i].get(); } + + private: + const StateTable *state_table_; + std::vector> accumulators_; + std::vector>> fst_array_; +}; + +// This class accumulates weights in a ReplaceFst. The 'Init' method takes as +// input the argument used to build the ReplaceFst and the ReplaceFst state +// table. It uses accumulators of type 'Accumulator' in the underlying FSTs. +template > +class ReplaceAccumulator { + public: + using Arc = typename Accumulator::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using StateTable = T; + using StateTuple = typename StateTable::StateTuple; + using Weight = typename Arc::Weight; + + ReplaceAccumulator() + : init_(false), + data_(std::make_shared< + ReplaceAccumulatorData>()), + error_(false) {} + + explicit ReplaceAccumulator(const std::vector &accumulators) + : init_(false), + data_(std::make_shared>( + accumulators)), + error_(false) {} + + ReplaceAccumulator(const ReplaceAccumulator &acc, + bool safe = false) + : init_(acc.init_), data_(acc.data_), error_(acc.error_) { + if (!init_) { + FSTERROR() << "ReplaceAccumulator: Can't copy unintialized accumulator"; + } + if (safe) FSTERROR() << "ReplaceAccumulator: Safe copy not supported"; + } + + // Does not take ownership of the state table, the state table is owned by + // the ReplaceFst. + void Init(const std::vector *>> &fst_tuples, + const StateTable *state_table) { + init_ = true; + data_->Init(fst_tuples, state_table); + } + + // Method required by LookAheadMatcher. However, ReplaceAccumulator needs to + // be initialized by calling the Init method above before being passed to + // LookAheadMatcher. + // + // TODO(allauzen): Revisit this. Consider creating a method + // Init(const ReplaceFst&, bool) and using friendship to get access + // to the innards of ReplaceFst. + void Init(const Fst &fst, bool copy = false) { + if (!init_) { + FSTERROR() << "ReplaceAccumulator::Init: Accumulator needs to be" + << " initialized before being passed to LookAheadMatcher"; + error_ = true; + } + } + + void SetState(StateId s) { + if (!init_) { + FSTERROR() << "ReplaceAccumulator::SetState: Incorrectly initialized"; + error_ = true; + return; + } + auto tuple = data_->GetTuple(s); + fst_id_ = tuple.fst_id - 1; // Replace FST ID is 1-based. + data_->GetAccumulator(fst_id_)->SetState(tuple.fst_state); + if ((tuple.prefix_id != 0) && + (data_->GetFst(fst_id_)->Final(tuple.fst_state) != Weight::Zero())) { + offset_ = 1; + offset_weight_ = data_->GetFst(fst_id_)->Final(tuple.fst_state); + } else { + offset_ = 0; + offset_weight_ = Weight::Zero(); + } + aiter_.reset( + new ArcIterator>(*data_->GetFst(fst_id_), tuple.fst_state)); + } + + Weight Sum(Weight w, Weight v) { + if (error_) return Weight::NoWeight(); + return data_->GetAccumulator(fst_id_)->Sum(w, v); + } + + template + Weight Sum(Weight w, ArcIter *aiter, ssize_t begin, ssize_t end) { + if (error_) return Weight::NoWeight(); + auto sum = begin == end ? Weight::Zero() + : data_->GetAccumulator(fst_id_)->Sum( + w, aiter_.get(), begin ? begin - offset_ : 0, + end - offset_); + if (begin == 0 && end != 0 && offset_ > 0) sum = Sum(offset_weight_, sum); + return sum; + } + + bool Error() const { return error_; } + + private: + bool init_; + std::shared_ptr> data_; + Label fst_id_; + size_t offset_; + Weight offset_weight_; + std::unique_ptr>> aiter_; + bool error_; +}; + +// SafeReplaceAccumulator accumulates weights in a ReplaceFst and copies of it +// are always thread-safe copies. +template +class SafeReplaceAccumulator { + public: + using Arc = typename Accumulator::Arc; + using StateId = typename Arc::StateId; + using Label = typename Arc::Label; + using Weight = typename Arc::Weight; + using StateTable = T; + using StateTuple = typename StateTable::StateTuple; + + SafeReplaceAccumulator() {} + + SafeReplaceAccumulator(const SafeReplaceAccumulator ©, bool safe) + : SafeReplaceAccumulator(copy) {} + + explicit SafeReplaceAccumulator( + const std::vector &accumulators) { + for (const auto &accumulator : accumulators) { + accumulators_.emplace_back(accumulator, true); + } + } + + void Init(const std::vector *>> &fst_tuples, + const StateTable *state_table) { + state_table_ = state_table; + for (Label i = 0; i < fst_tuples.size(); ++i) { + if (i == accumulators_.size()) { + accumulators_.resize(accumulators_.size() + 1); + accumulators_[i].Init(*(fst_tuples[i].second)); + } + fst_array_.emplace_back(fst_tuples[i].second->Copy(true)); + } + init_ = true; + } + + void Init(const Fst &fst, bool copy = false) { + if (!init_) { + FSTERROR() << "SafeReplaceAccumulator::Init: Accumulator needs to be" + << " initialized before being passed to LookAheadMatcher"; + error_ = true; + } + } + + void SetState(StateId s) { + auto tuple = state_table_->Tuple(s); + fst_id_ = tuple.fst_id - 1; // Replace FST ID is 1-based + GetAccumulator(fst_id_)->SetState(tuple.fst_state); + offset_ = 0; + offset_weight_ = Weight::Zero(); + const auto final_weight = GetFst(fst_id_)->Final(tuple.fst_state); + if ((tuple.prefix_id != 0) && (final_weight != Weight::Zero())) { + offset_ = 1; + offset_weight_ = final_weight; + } + aiter_.Set(*GetFst(fst_id_), tuple.fst_state); + } + + Weight Sum(Weight w, Weight v) { + if (error_) return Weight::NoWeight(); + return GetAccumulator(fst_id_)->Sum(w, v); + } + + template + Weight Sum(Weight w, ArcIter *aiter, ssize_t begin, ssize_t end) { + if (error_) return Weight::NoWeight(); + if (begin == end) return Weight::Zero(); + auto sum = GetAccumulator(fst_id_)->Sum( + w, aiter_.get(), begin ? begin - offset_ : 0, end - offset_); + if (begin == 0 && end != 0 && offset_ > 0) { + sum = Sum(offset_weight_, sum); + } + return sum; + } + + bool Error() const { return error_; } + + private: + class ArcIteratorPtr { + public: + ArcIteratorPtr() {} + + ArcIteratorPtr(const ArcIteratorPtr ©) {} + + void Set(const Fst &fst, StateId state_id) { + ptr_.reset(new ArcIterator>(fst, state_id)); + } + + ArcIterator> *get() { return ptr_.get(); } + + private: + std::unique_ptr>> ptr_; + }; + + Accumulator *GetAccumulator(size_t i) { return &accumulators_[i]; } + + const Fst *GetFst(size_t i) const { return fst_array_[i].get(); } + + const StateTable *state_table_; + std::vector accumulators_; + std::vector>> fst_array_; + ArcIteratorPtr aiter_; + bool init_ = false; + bool error_ = false; + Label fst_id_; + size_t offset_; + Weight offset_weight_; +}; + +} // namespace fst + +#endif // FST_ACCUMULATOR_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/add-on.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/add-on.h new file mode 100644 index 0000000000..4a95111ff8 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/add-on.h @@ -0,0 +1,248 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// FST implementation class to attach an arbitrary object with a read/write +// method to an FST and its file representation. The FST is given a new type +// name. + +#ifndef FST_ADD_ON_H_ +#define FST_ADD_ON_H_ + +#include +#include +#include +#include + +#include + +#include + + +namespace fst { + +// Identifies stream data as an add-on FST. +static constexpr int32 kAddOnMagicNumber = 446681434; + +// Nothing to save. +class NullAddOn { + public: + NullAddOn() {} + + static NullAddOn *Read(std::istream &strm, const FstReadOptions &opts) { + return new NullAddOn(); + } + + bool Write(std::ostream &ostrm, const FstWriteOptions &opts) const { + return true; + } +}; + +// Create a new add-on from a pair of add-ons. +template +class AddOnPair { + public: + // Argument reference count incremented. + AddOnPair(std::shared_ptr a1, std::shared_ptr a2) + : a1_(std::move(a1)), a2_(std::move(a2)) {} + + const A1 *First() const { return a1_.get(); } + + const A2 *Second() const { return a2_.get(); } + + std::shared_ptr SharedFirst() const { return a1_; } + + std::shared_ptr SharedSecond() const { return a2_; } + + static AddOnPair *Read(std::istream &istrm, + const FstReadOptions &opts) { + A1 *a1 = nullptr; + bool have_addon1 = false; + ReadType(istrm, &have_addon1); + if (have_addon1) a1 = A1::Read(istrm, opts); + + A2 *a2 = nullptr; + bool have_addon2 = false; + ReadType(istrm, &have_addon2); + if (have_addon2) a2 = A2::Read(istrm, opts); + + return new AddOnPair(std::shared_ptr(a1), + std::shared_ptr(a2)); + } + + bool Write(std::ostream &ostrm, const FstWriteOptions &opts) const { + bool have_addon1 = a1_ != nullptr; + WriteType(ostrm, have_addon1); + if (have_addon1) a1_->Write(ostrm, opts); + bool have_addon2 = a2_ != nullptr; + WriteType(ostrm, have_addon2); + if (have_addon2) a2_->Write(ostrm, opts); + return true; + } + + private: + std::shared_ptr a1_; + std::shared_ptr a2_; +}; + +namespace internal { + +// Adds an object of type T to an FST. T must support: +// +// T* Read(std::istream &); +// bool Write(std::ostream &); +// +// The resulting type is a new FST implementation. +template +class AddOnImpl : public FstImpl { + public: + using Arc = typename FST::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using FstImpl::SetType; + using FstImpl::SetInputSymbols; + using FstImpl::SetOutputSymbols; + using FstImpl::SetProperties; + using FstImpl::WriteHeader; + + // We make a thread-safe copy of the FST by default since an FST + // implementation is expected to not share mutable data between objects. + AddOnImpl(const FST &fst, const string &type, + std::shared_ptr t = std::shared_ptr()) + : fst_(fst, true), t_(std::move(t)) { + SetType(type); + SetProperties(fst_.Properties(kFstProperties, false)); + SetInputSymbols(fst_.InputSymbols()); + SetOutputSymbols(fst_.OutputSymbols()); + } + + // Conversion from const Fst & to F always copies the underlying + // implementation. + AddOnImpl(const Fst &fst, const string &type, + std::shared_ptr t = std::shared_ptr()) + : fst_(fst), t_(std::move(t)) { + SetType(type); + SetProperties(fst_.Properties(kFstProperties, false)); + SetInputSymbols(fst_.InputSymbols()); + SetOutputSymbols(fst_.OutputSymbols()); + } + + // We make a thread-safe copy of the FST by default since an FST + // implementation is expected to not share mutable data between objects. + AddOnImpl(const AddOnImpl &impl) + : fst_(impl.fst_, true), t_(impl.t_) { + SetType(impl.Type()); + SetProperties(fst_.Properties(kCopyProperties, false)); + SetInputSymbols(fst_.InputSymbols()); + SetOutputSymbols(fst_.OutputSymbols()); + } + + StateId Start() const { return fst_.Start(); } + + Weight Final(StateId s) const { return fst_.Final(s); } + + size_t NumArcs(StateId s) const { return fst_.NumArcs(s); } + + size_t NumInputEpsilons(StateId s) const { return fst_.NumInputEpsilons(s); } + + size_t NumOutputEpsilons(StateId s) const { + return fst_.NumOutputEpsilons(s); + } + + size_t NumStates() const { return fst_.NumStates(); } + + static AddOnImpl *Read(std::istream &strm, + const FstReadOptions &opts) { + FstReadOptions nopts(opts); + FstHeader hdr; + if (!nopts.header) { + hdr.Read(strm, nopts.source); + nopts.header = &hdr; + } + std::unique_ptr> impl( + new AddOnImpl(nopts.header->FstType())); + if (!impl->ReadHeader(strm, nopts, kMinFileVersion, &hdr)) return nullptr; + impl.reset(); + int32 magic_number = 0; + ReadType(strm, &magic_number); // Ensures this is an add-on FST. + if (magic_number != kAddOnMagicNumber) { + LOG(ERROR) << "AddOnImpl::Read: Bad add-on header: " << nopts.source; + return nullptr; + } + FstReadOptions fopts(opts); + fopts.header = nullptr; // Contained header was written out. + std::unique_ptr fst(FST::Read(strm, fopts)); + if (!fst) return nullptr; + std::shared_ptr t; + bool have_addon = false; + ReadType(strm, &have_addon); + if (have_addon) { // Reads add-on object if present. + t = std::shared_ptr(T::Read(strm, fopts)); + if (!t) return nullptr; + } + return new AddOnImpl(*fst, nopts.header->FstType(), t); + } + + bool Write(std::ostream &strm, const FstWriteOptions &opts) const { + FstHeader hdr; + FstWriteOptions nopts(opts); + nopts.write_isymbols = false; // Allows contained FST to hold any symbols. + nopts.write_osymbols = false; + WriteHeader(strm, nopts, kFileVersion, &hdr); + WriteType(strm, kAddOnMagicNumber); // Ensures this is an add-on FST. + FstWriteOptions fopts(opts); + fopts.write_header = true; // Forces writing contained header. + if (!fst_.Write(strm, fopts)) return false; + bool have_addon = !!t_; + WriteType(strm, have_addon); + // Writes add-on object if present. + if (have_addon) t_->Write(strm, opts); + return true; + } + + void InitStateIterator(StateIteratorData *data) const { + fst_.InitStateIterator(data); + } + + void InitArcIterator(StateId s, ArcIteratorData *data) const { + fst_.InitArcIterator(s, data); + } + + FST &GetFst() { return fst_; } + + const FST &GetFst() const { return fst_; } + + const T *GetAddOn() const { return t_.get(); } + + std::shared_ptr GetSharedAddOn() const { return t_; } + + void SetAddOn(std::shared_ptr t) { t_ = t; } + + private: + explicit AddOnImpl(const string &type) : t_() { + SetType(type); + SetProperties(kExpanded); + } + + // Current file format version. + static constexpr int kFileVersion = 1; + // Minimum file format version supported. + static constexpr int kMinFileVersion = 1; + + FST fst_; + std::shared_ptr t_; + + AddOnImpl &operator=(const AddOnImpl &) = delete; +}; + +template +constexpr int AddOnImpl::kFileVersion; + +template +constexpr int AddOnImpl::kMinFileVersion; + +} // namespace internal +} // namespace fst + +#endif // FST_ADD_ON_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/arc-arena.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/arc-arena.h new file mode 100644 index 0000000000..13fe918a58 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/arc-arena.h @@ -0,0 +1,232 @@ +#ifndef FST_ARC_ARENA_H_ +#define FST_ARC_ARENA_H_ + +#include +#include +#include +#include +#include +#include + +namespace fst { + +// ArcArena is used for fast allocation of contiguous arrays of arcs. +// +// To create an arc array: +// for each state: +// for each arc: +// arena.PushArc(); +// // Commits these arcs and returns pointer to them. +// Arc *arcs = arena.GetArcs(); +// +// OR +// +// arena.DropArcs(); // Throws away current arcs, reuse the space. +// +// The arcs returned are guaranteed to be contiguous and the pointer returned +// will never be invalidated until the arena is cleared for reuse. +// +// The contents of the arena can be released with a call to arena.Clear() after +// which the arena will restart with an initial allocation capable of holding at +// least all of the arcs requested in the last usage before Clear() making +// subsequent uses of the Arena more efficient. +// +// The max_retained_size option can limit the amount of arc space requested on +// Clear() to avoid excess growth from intermittent high usage. +template +class ArcArena { + public: + explicit ArcArena(size_t block_size = 256, + size_t max_retained_size = 1e6) + : block_size_(block_size), + max_retained_size_(max_retained_size) { + blocks_.emplace_back(MakeSharedBlock(block_size_)); + first_block_size_ = block_size_; + total_size_ = block_size_; + arcs_ = blocks_.back().get(); + end_ = arcs_ + block_size_; + next_ = arcs_; + } + + ArcArena(const ArcArena& copy) + : arcs_(copy.arcs_), next_(copy.next_), end_(copy.end_), + block_size_(copy.block_size_), + first_block_size_(copy.first_block_size_), + total_size_(copy.total_size_), + max_retained_size_(copy.max_retained_size_), + blocks_(copy.blocks_) { + NewBlock(block_size_); + } + + void ReserveArcs(size_t n) { + if (next_ + n < end_) return; + NewBlock(n); + } + + void PushArc(const Arc& arc) { + if (next_ == end_) { + size_t length = next_ - arcs_; + NewBlock(length * 2); + } + *next_ = arc; + ++next_; + } + + const Arc* GetArcs() { + const auto *arcs = arcs_; + arcs_ = next_; + return arcs; + } + + void DropArcs() { next_ = arcs_; } + + size_t Size() { return total_size_; } + + void Clear() { + blocks_.resize(1); + if (total_size_ > first_block_size_) { + first_block_size_ = std::min(max_retained_size_, total_size_); + blocks_.back() = MakeSharedBlock(first_block_size_); + } + total_size_ = first_block_size_; + arcs_ = blocks_.back().get(); + end_ = arcs_ + first_block_size_; + next_ = arcs_; + } + + private: + // Allocates a new block with capacity of at least n or block_size, + // copying incomplete arc sequence from old block to new block. + void NewBlock(size_t n) { + const auto length = next_ - arcs_; + const auto new_block_size = std::max(n, block_size_); + total_size_ += new_block_size; + blocks_.emplace_back(MakeSharedBlock(new_block_size)); + std::copy(arcs_, next_, blocks_.back().get()); + arcs_ = blocks_.back().get(); + next_ = arcs_ + length; + end_ = arcs_ + new_block_size; + } + + std::shared_ptr MakeSharedBlock(size_t size) { + return std::shared_ptr(new Arc[size], std::default_delete()); + } + + Arc *arcs_; + Arc *next_; + const Arc *end_; + size_t block_size_; + size_t first_block_size_; + size_t total_size_; + size_t max_retained_size_; + std::list> blocks_; +}; + +// ArcArenaStateStore uses a resusable ArcArena to store arc arrays and does not +// require that the Expander call ReserveArcs first. +// +// TODO(tombagby): Make cache type configurable. +// TODO(tombagby): Provide ThreadLocal/Concurrent configuration. +template +class ArcArenaStateStore { + public: + using Arc = A; + using Weight = typename Arc::Weight; + using StateId = typename Arc::StateId; + + ArcArenaStateStore() : arena_(64 * 1024) { + } + + class State { + public: + Weight Final() const { return final_; } + + size_t NumInputEpsilons() const { return niepsilons_; } + + size_t NumOutputEpsilons() const { return noepsilons_; } + + size_t NumArcs() const { return narcs_; } + + const Arc &GetArc(size_t n) const { return arcs_[n]; } + + const Arc *Arcs() const { return arcs_; } + + int* MutableRefCount() const { return nullptr; } + + private: + State(Weight weight, int32 niepsilons, int32 noepsilons, int32 narcs, + const Arc *arcs) + : final_(std::move(weight)), + niepsilons_(niepsilons), + noepsilons_(noepsilons), + narcs_(narcs), + arcs_(arcs) {} + + Weight final_; + size_t niepsilons_; + size_t noepsilons_; + size_t narcs_; + const Arc *arcs_; + + friend class ArcArenaStateStore; + }; + + template + State *FindOrExpand(Expander &expander, StateId state_id) { // NOLINT + auto it = cache_.insert(std::pair(state_id, nullptr)); + if (!it.second) return it.first->second; + // Needs a new state. + StateBuilder builder(&arena_); + expander.Expand(state_id, &builder); + const auto arcs = arena_.GetArcs(); + size_t narcs = builder.narcs_; + size_t niepsilons = 0; + size_t noepsilons = 0; + for (size_t i = 0; i < narcs; ++i) { + if (arcs[i].ilabel == 0) ++niepsilons; + if (arcs[i].olabel == 0) ++noepsilons; + } + states_.emplace_back( + State(builder.final_, niepsilons, noepsilons, narcs, arcs)); + // Places it in the cache. + auto state = &states_.back(); + it.first->second = state; + return state; + } + + State *Find(StateId state_id) const { + auto it = cache_.find(state_id); + return (it == cache_.end()) ? nullptr : it->second; + } + + private: + class StateBuilder { + public: + explicit StateBuilder(ArcArena* arena) + : arena_(arena), final_(Weight::Zero()), narcs_(0) {} + + void SetFinal(Weight weight) { final_ = std::move(weight); } + + void ReserveArcs(size_t n) { arena_->ReserveArcs(n); } + + void AddArc(const Arc &arc) { + ++narcs_; + arena_->PushArc(arc); + } + + private: + friend class ArcArenaStateStore; + + ArcArena *arena_; + Weight final_; + size_t narcs_; + }; + + std::unordered_map cache_; + std::deque states_; + ArcArena arena_; +}; + +} // namespace fst + +#endif // FST_ARC_ARENA_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/arc-map.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/arc-map.h new file mode 100644 index 0000000000..ec0d8fd5e8 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/arc-map.h @@ -0,0 +1,1286 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Class to map over/transform arcs e.g., change semirings or +// implement project/invert. Consider using when operation does +// not change the number of arcs (except possibly superfinal arcs). + +#ifndef FST_ARC_MAP_H_ +#define FST_ARC_MAP_H_ + +#include +#include +#include + +#include + +#include +#include + + +namespace fst { + +// Determines how final weights are mapped. +enum MapFinalAction { + // A final weight is mapped into a final weight. An error is raised if this + // is not possible. + MAP_NO_SUPERFINAL, + // A final weight is mapped to an arc to the superfinal state when the result + // cannot be represented as a final weight. The superfinal state will be + // added only if it is needed. + MAP_ALLOW_SUPERFINAL, + // A final weight is mapped to an arc to the superfinal state unless the + // result can be represented as a final weight of weight Zero(). The + // superfinal state is always added (if the input is not the empty FST). + MAP_REQUIRE_SUPERFINAL +}; + +// Determines how symbol tables are mapped. +enum MapSymbolsAction { + // Symbols should be cleared in the result by the map. + MAP_CLEAR_SYMBOLS, + // Symbols should be copied from the input FST by the map. + MAP_COPY_SYMBOLS, + // Symbols should not be modified in the result by the map itself. + // (They may set by the mapper). + MAP_NOOP_SYMBOLS +}; + +// The ArcMapper interfaces defines how arcs and final weights are mapped. +// This is useful for implementing operations that do not change the number of +// arcs (expect possibly superfinal arcs). +// +// template +// class ArcMapper { +// public: +// using FromArc = A; +// using ToArc = B; +// +// // Maps an arc type FromArc to arc type ToArc. +// ToArc operator()(const FromArc &arc); +// +// // Specifies final action the mapper requires (see above). +// // The mapper will be passed final weights as arcs of the form +// // Arc(0, 0, weight, kNoStateId). +// MapFinalAction FinalAction() const; +// +// // Specifies input symbol table action the mapper requires (see above). +// MapSymbolsAction InputSymbolsAction() const; +// +// // Specifies output symbol table action the mapper requires (see above). +// MapSymbolsAction OutputSymbolsAction() const; +// +// // This specifies the known properties of an FST mapped by this mapper. It +// takes as argument the input FSTs's known properties. +// uint64 Properties(uint64 props) const; +// }; +// +// The ArcMap functions and classes below will use the FinalAction() +// method of the mapper to determine how to treat final weights, e.g., whether +// to add a superfinal state. They will use the Properties() method to set the +// result FST properties. +// +// We include a various map versions below. One dimension of variation is +// whether the mapping mutates its input, writes to a new result FST, or is an +// on-the-fly FST. Another dimension is how we pass the mapper. We allow passing +// the mapper by pointer for cases that we need to change the state of the +// user's mapper. This is the case with the EncodeMapper, which is reused +// during decoding. We also include map versions that pass the mapper by value +// or const reference when this suffices. + +// Maps an arc type A using a mapper function object C, passed +// by pointer. This version modifies its Fst input. +template +void ArcMap(MutableFst *fst, C *mapper) { + using FromArc = A; + using ToArc = A; + using StateId = typename FromArc::StateId; + using Weight = typename FromArc::Weight; + if (mapper->InputSymbolsAction() == MAP_CLEAR_SYMBOLS) { + fst->SetInputSymbols(nullptr); + } + if (mapper->OutputSymbolsAction() == MAP_CLEAR_SYMBOLS) { + fst->SetOutputSymbols(nullptr); + } + if (fst->Start() == kNoStateId) return; + const auto props = fst->Properties(kFstProperties, false); + const auto final_action = mapper->FinalAction(); + auto superfinal = kNoStateId; + if (final_action == MAP_REQUIRE_SUPERFINAL) { + superfinal = fst->AddState(); + fst->SetFinal(superfinal, Weight::One()); + } + for (StateIterator> siter(*fst); !siter.Done(); + siter.Next()) { + const auto state = siter.Value(); + for (MutableArcIterator> aiter(fst, state); + !aiter.Done(); aiter.Next()) { + const auto &arc = aiter.Value(); + aiter.SetValue((*mapper)(arc)); + } + switch (final_action) { + case MAP_NO_SUPERFINAL: + default: { + const FromArc arc(0, 0, fst->Final(state), kNoStateId); + const auto final_arc = (*mapper)(arc); + if (final_arc.ilabel != 0 || final_arc.olabel != 0) { + FSTERROR() << "ArcMap: Non-zero arc labels for superfinal arc"; + fst->SetProperties(kError, kError); + } + fst->SetFinal(state, final_arc.weight); + break; + } + case MAP_ALLOW_SUPERFINAL: { + if (state != superfinal) { + const FromArc arc(0, 0, fst->Final(state), kNoStateId); + auto final_arc = (*mapper)(arc); + if (final_arc.ilabel != 0 || final_arc.olabel != 0) { + // Add a superfinal state if not already done. + if (superfinal == kNoStateId) { + superfinal = fst->AddState(); + fst->SetFinal(superfinal, Weight::One()); + } + final_arc.nextstate = superfinal; + fst->AddArc(state, final_arc); + fst->SetFinal(state, Weight::Zero()); + } else { + fst->SetFinal(state, final_arc.weight); + } + } + break; + } + case MAP_REQUIRE_SUPERFINAL: { + if (state != superfinal) { + const FromArc arc(0, 0, fst->Final(state), kNoStateId); + const auto final_arc = (*mapper)(arc); + if (final_arc.ilabel != 0 || final_arc.olabel != 0 || + final_arc.weight != Weight::Zero()) { + fst->AddArc(state, ToArc(final_arc.ilabel, final_arc.olabel, + final_arc.weight, superfinal)); + } + fst->SetFinal(state, Weight::Zero()); + } + break; + } + } + } + fst->SetProperties(mapper->Properties(props), kFstProperties); +} + +// Maps an arc type A using a mapper function object C, passed by value. This +// version modifies its FST input. +template +void ArcMap(MutableFst *fst, C mapper) { + ArcMap(fst, &mapper); +} + +// Maps an arc type A to an arc type B using mapper function object C, +// passed by pointer. This version writes the mapped input FST to an +// output MutableFst. +template +void ArcMap(const Fst &ifst, MutableFst *ofst, C *mapper) { + using FromArc = A; + using StateId = typename FromArc::StateId; + using Weight = typename FromArc::Weight; + ofst->DeleteStates(); + if (mapper->InputSymbolsAction() == MAP_COPY_SYMBOLS) { + ofst->SetInputSymbols(ifst.InputSymbols()); + } else if (mapper->InputSymbolsAction() == MAP_CLEAR_SYMBOLS) { + ofst->SetInputSymbols(nullptr); + } + if (mapper->OutputSymbolsAction() == MAP_COPY_SYMBOLS) { + ofst->SetOutputSymbols(ifst.OutputSymbols()); + } else if (mapper->OutputSymbolsAction() == MAP_CLEAR_SYMBOLS) { + ofst->SetOutputSymbols(nullptr); + } + const auto iprops = ifst.Properties(kCopyProperties, false); + if (ifst.Start() == kNoStateId) { + if (iprops & kError) ofst->SetProperties(kError, kError); + return; + } + const auto final_action = mapper->FinalAction(); + if (ifst.Properties(kExpanded, false)) { + ofst->ReserveStates( + CountStates(ifst) + final_action == MAP_NO_SUPERFINAL ? 0 : 1); + } + // Adds all states. + for (StateIterator> siter(ifst); !siter.Done(); siter.Next()) { + ofst->AddState(); + } + StateId superfinal = kNoStateId; + if (final_action == MAP_REQUIRE_SUPERFINAL) { + superfinal = ofst->AddState(); + ofst->SetFinal(superfinal, B::Weight::One()); + } + for (StateIterator> siter(ifst); !siter.Done(); siter.Next()) { + StateId s = siter.Value(); + if (s == ifst.Start()) ofst->SetStart(s); + ofst->ReserveArcs(s, ifst.NumArcs(s)); + for (ArcIterator> aiter(ifst, s); !aiter.Done(); aiter.Next()) { + ofst->AddArc(s, (*mapper)(aiter.Value())); + } + switch (final_action) { + case MAP_NO_SUPERFINAL: + default: { + B final_arc = (*mapper)(A(0, 0, ifst.Final(s), kNoStateId)); + if (final_arc.ilabel != 0 || final_arc.olabel != 0) { + FSTERROR() << "ArcMap: Non-zero arc labels for superfinal arc"; + ofst->SetProperties(kError, kError); + } + ofst->SetFinal(s, final_arc.weight); + break; + } + case MAP_ALLOW_SUPERFINAL: { + B final_arc = (*mapper)(A(0, 0, ifst.Final(s), kNoStateId)); + if (final_arc.ilabel != 0 || final_arc.olabel != 0) { + // Add a superfinal state if not already done. + if (superfinal == kNoStateId) { + superfinal = ofst->AddState(); + ofst->SetFinal(superfinal, B::Weight::One()); + } + final_arc.nextstate = superfinal; + ofst->AddArc(s, final_arc); + ofst->SetFinal(s, B::Weight::Zero()); + } else { + ofst->SetFinal(s, final_arc.weight); + } + break; + } + case MAP_REQUIRE_SUPERFINAL: { + B final_arc = (*mapper)(A(0, 0, ifst.Final(s), kNoStateId)); + if (final_arc.ilabel != 0 || final_arc.olabel != 0 || + final_arc.weight != B::Weight::Zero()) { + ofst->AddArc(s, B(final_arc.ilabel, final_arc.olabel, + final_arc.weight, superfinal)); + } + ofst->SetFinal(s, B::Weight::Zero()); + break; + } + } + } + const auto oprops = ofst->Properties(kFstProperties, false); + ofst->SetProperties(mapper->Properties(iprops) | oprops, kFstProperties); +} + +// Maps an arc type A to an arc type B using mapper function +// object C, passed by value. This version writes the mapped input +// Fst to an output MutableFst. +template +void ArcMap(const Fst &ifst, MutableFst *ofst, C mapper) { + ArcMap(ifst, ofst, &mapper); +} + +struct ArcMapFstOptions : public CacheOptions { + // ArcMapFst default caching behaviour is to do no caching. Most mappers are + // cheap and therefore we save memory by not doing caching. + ArcMapFstOptions() : CacheOptions(true, 0) {} + + explicit ArcMapFstOptions(const CacheOptions &opts) : CacheOptions(opts) {} +}; + +template +class ArcMapFst; + +namespace internal { + +// Implementation of delayed ArcMapFst. +template +class ArcMapFstImpl : public CacheImpl { + public: + using Arc = B; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using FstImpl::SetType; + using FstImpl::SetProperties; + using FstImpl::SetInputSymbols; + using FstImpl::SetOutputSymbols; + + using CacheImpl::PushArc; + using CacheImpl::HasArcs; + using CacheImpl::HasFinal; + using CacheImpl::HasStart; + using CacheImpl::SetArcs; + using CacheImpl::SetFinal; + using CacheImpl::SetStart; + + friend class StateIterator>; + + ArcMapFstImpl(const Fst &fst, const C &mapper, + const ArcMapFstOptions &opts) + : CacheImpl(opts), + fst_(fst.Copy()), + mapper_(new C(mapper)), + own_mapper_(true), + superfinal_(kNoStateId), + nstates_(0) { + Init(); + } + + ArcMapFstImpl(const Fst &fst, C *mapper, const ArcMapFstOptions &opts) + : CacheImpl(opts), + fst_(fst.Copy()), + mapper_(mapper), + own_mapper_(false), + superfinal_(kNoStateId), + nstates_(0) { + Init(); + } + + ArcMapFstImpl(const ArcMapFstImpl &impl) + : CacheImpl(impl), + fst_(impl.fst_->Copy(true)), + mapper_(new C(*impl.mapper_)), + own_mapper_(true), + superfinal_(kNoStateId), + nstates_(0) { + Init(); + } + + ~ArcMapFstImpl() override { + if (own_mapper_) delete mapper_; + } + + StateId Start() { + if (!HasStart()) SetStart(FindOState(fst_->Start())); + return CacheImpl::Start(); + } + + Weight Final(StateId s) { + if (!HasFinal(s)) { + switch (final_action_) { + case MAP_NO_SUPERFINAL: + default: { + const auto final_arc = + (*mapper_)(A(0, 0, fst_->Final(FindIState(s)), kNoStateId)); + if (final_arc.ilabel != 0 || final_arc.olabel != 0) { + FSTERROR() << "ArcMapFst: Non-zero arc labels for superfinal arc"; + SetProperties(kError, kError); + } + SetFinal(s, final_arc.weight); + break; + } + case MAP_ALLOW_SUPERFINAL: { + if (s == superfinal_) { + SetFinal(s, Weight::One()); + } else { + const auto final_arc = + (*mapper_)(A(0, 0, fst_->Final(FindIState(s)), kNoStateId)); + if (final_arc.ilabel == 0 && final_arc.olabel == 0) { + SetFinal(s, final_arc.weight); + } else { + SetFinal(s, Weight::Zero()); + } + } + break; + } + case MAP_REQUIRE_SUPERFINAL: { + SetFinal(s, s == superfinal_ ? Weight::One() : Weight::Zero()); + break; + } + } + } + return CacheImpl::Final(s); + } + + size_t NumArcs(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumArcs(s); + } + + size_t NumInputEpsilons(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumInputEpsilons(s); + } + + size_t NumOutputEpsilons(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumOutputEpsilons(s); + } + + uint64 Properties() const override { return Properties(kFstProperties); } + + // Sets error if found, and returns other FST impl properties. + uint64 Properties(uint64 mask) const override { + if ((mask & kError) && (fst_->Properties(kError, false) || + (mapper_->Properties(0) & kError))) { + SetProperties(kError, kError); + } + return FstImpl::Properties(mask); + } + + void InitArcIterator(StateId s, ArcIteratorData *data) { + if (!HasArcs(s)) Expand(s); + CacheImpl::InitArcIterator(s, data); + } + + void Expand(StateId s) { + // Add exiting arcs. + if (s == superfinal_) { + SetArcs(s); + return; + } + for (ArcIterator> aiter(*fst_, FindIState(s)); !aiter.Done(); + aiter.Next()) { + auto aarc = aiter.Value(); + aarc.nextstate = FindOState(aarc.nextstate); + const auto &barc = (*mapper_)(aarc); + PushArc(s, barc); + } + + // Check for superfinal arcs. + if (!HasFinal(s) || Final(s) == Weight::Zero()) { + switch (final_action_) { + case MAP_NO_SUPERFINAL: + default: + break; + case MAP_ALLOW_SUPERFINAL: { + auto final_arc = + (*mapper_)(A(0, 0, fst_->Final(FindIState(s)), kNoStateId)); + if (final_arc.ilabel != 0 || final_arc.olabel != 0) { + if (superfinal_ == kNoStateId) superfinal_ = nstates_++; + final_arc.nextstate = superfinal_; + PushArc(s, final_arc); + } + break; + } + case MAP_REQUIRE_SUPERFINAL: { + const auto final_arc = + (*mapper_)(A(0, 0, fst_->Final(FindIState(s)), kNoStateId)); + if (final_arc.ilabel != 0 || final_arc.olabel != 0 || + final_arc.weight != B::Weight::Zero()) { + PushArc(s, B(final_arc.ilabel, final_arc.olabel, final_arc.weight, + superfinal_)); + } + break; + } + } + } + SetArcs(s); + } + + private: + void Init() { + SetType("map"); + if (mapper_->InputSymbolsAction() == MAP_COPY_SYMBOLS) { + SetInputSymbols(fst_->InputSymbols()); + } else if (mapper_->InputSymbolsAction() == MAP_CLEAR_SYMBOLS) { + SetInputSymbols(nullptr); + } + if (mapper_->OutputSymbolsAction() == MAP_COPY_SYMBOLS) { + SetOutputSymbols(fst_->OutputSymbols()); + } else if (mapper_->OutputSymbolsAction() == MAP_CLEAR_SYMBOLS) { + SetOutputSymbols(nullptr); + } + if (fst_->Start() == kNoStateId) { + final_action_ = MAP_NO_SUPERFINAL; + SetProperties(kNullProperties); + } else { + final_action_ = mapper_->FinalAction(); + uint64 props = fst_->Properties(kCopyProperties, false); + SetProperties(mapper_->Properties(props)); + if (final_action_ == MAP_REQUIRE_SUPERFINAL) superfinal_ = 0; + } + } + + // Maps from output state to input state. + StateId FindIState(StateId s) { + if (superfinal_ == kNoStateId || s < superfinal_) { + return s; + } else { + return s - 1; + } + } + + // Maps from input state to output state. + StateId FindOState(StateId is) { + auto os = is; + if (!(superfinal_ == kNoStateId || is < superfinal_)) ++os; + if (os >= nstates_) nstates_ = os + 1; + return os; + } + + std::unique_ptr> fst_; + C *mapper_; + const bool own_mapper_; + MapFinalAction final_action_; + StateId superfinal_; + StateId nstates_; +}; + +} // namespace internal + +// Maps an arc type A to an arc type B using Mapper function object +// C. This version is a delayed FST. +template +class ArcMapFst : public ImplToFst> { + public: + using Arc = B; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using Store = DefaultCacheStore; + using State = typename Store::State; + using Impl = internal::ArcMapFstImpl; + + friend class ArcIterator>; + friend class StateIterator>; + + ArcMapFst(const Fst &fst, const C &mapper, const ArcMapFstOptions &opts) + : ImplToFst(std::make_shared(fst, mapper, opts)) {} + + ArcMapFst(const Fst &fst, C *mapper, const ArcMapFstOptions &opts) + : ImplToFst(std::make_shared(fst, mapper, opts)) {} + + ArcMapFst(const Fst &fst, const C &mapper) + : ImplToFst( + std::make_shared(fst, mapper, ArcMapFstOptions())) {} + + ArcMapFst(const Fst &fst, C *mapper) + : ImplToFst( + std::make_shared(fst, mapper, ArcMapFstOptions())) {} + + // See Fst<>::Copy() for doc. + ArcMapFst(const ArcMapFst &fst, bool safe = false) + : ImplToFst(fst, safe) {} + + // Get a copy of this ArcMapFst. See Fst<>::Copy() for further doc. + ArcMapFst *Copy(bool safe = false) const override { + return new ArcMapFst(*this, safe); + } + + inline void InitStateIterator(StateIteratorData *data) const override; + + void InitArcIterator(StateId s, ArcIteratorData *data) const override { + GetMutableImpl()->InitArcIterator(s, data); + } + + protected: + using ImplToFst::GetImpl; + using ImplToFst::GetMutableImpl; + + private: + ArcMapFst &operator=(const ArcMapFst &) = delete; +}; + +// Specialization for ArcMapFst. +// +// This may be derived from. +template +class StateIterator> : public StateIteratorBase { + public: + using StateId = typename B::StateId; + + explicit StateIterator(const ArcMapFst &fst) + : impl_(fst.GetImpl()), + siter_(*impl_->fst_), + s_(0), + superfinal_(impl_->final_action_ == MAP_REQUIRE_SUPERFINAL) { + CheckSuperfinal(); + } + + bool Done() const final { return siter_.Done() && !superfinal_; } + + StateId Value() const final { return s_; } + + void Next() final { + ++s_; + if (!siter_.Done()) { + siter_.Next(); + CheckSuperfinal(); + } else if (superfinal_) { + superfinal_ = false; + } + } + + void Reset() final { + s_ = 0; + siter_.Reset(); + superfinal_ = impl_->final_action_ == MAP_REQUIRE_SUPERFINAL; + CheckSuperfinal(); + } + + private: + void CheckSuperfinal() { + if (impl_->final_action_ != MAP_ALLOW_SUPERFINAL || superfinal_) return; + if (!siter_.Done()) { + const auto final_arc = + (*impl_->mapper_)(A(0, 0, impl_->fst_->Final(s_), kNoStateId)); + if (final_arc.ilabel != 0 || final_arc.olabel != 0) superfinal_ = true; + } + } + + const internal::ArcMapFstImpl *impl_; + StateIterator> siter_; + StateId s_; + bool superfinal_; // True if there is a superfinal state and not done. +}; + +// Specialization for ArcMapFst. +template +class ArcIterator> + : public CacheArcIterator> { + public: + using StateId = typename A::StateId; + + ArcIterator(const ArcMapFst &fst, StateId s) + : CacheArcIterator>(fst.GetMutableImpl(), s) { + if (!fst.GetImpl()->HasArcs(s)) fst.GetMutableImpl()->Expand(s); + } +}; + +template +inline void ArcMapFst::InitStateIterator( + StateIteratorData *data) const { + data->base = new StateIterator>(*this); +} + +// Utility Mappers. + +// Mapper that returns its input. +template +class IdentityArcMapper { + public: + using FromArc = A; + using ToArc = A; + + ToArc operator()(const FromArc &arc) const { return arc; } + + constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; } + + constexpr MapSymbolsAction InputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + constexpr MapSymbolsAction OutputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + uint64 Properties(uint64 props) const { return props; } +}; + +// Mapper that converts all input symbols to epsilon. +template +class InputEpsilonMapper { + public: + using FromArc = A; + using ToArc = A; + + ToArc operator()(const FromArc &arc) const { + return ToArc(0, arc.olabel, arc.weight, arc.nextstate); + } + + constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; } + + constexpr MapSymbolsAction InputSymbolsAction() const { + return MAP_CLEAR_SYMBOLS; + } + + constexpr MapSymbolsAction OutputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + uint64 Properties(uint64 props) const { + return (props & kSetArcProperties) | kIEpsilons; + } +}; + +// Mapper that converts all output symbols to epsilon. +template +class OutputEpsilonMapper { + public: + using FromArc = A; + using ToArc = A; + + ToArc operator()(const FromArc &arc) const { + return ToArc(arc.ilabel, 0, arc.weight, arc.nextstate); + } + + constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; } + + constexpr MapSymbolsAction InputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + constexpr MapSymbolsAction OutputSymbolsAction() const { + return MAP_CLEAR_SYMBOLS; + } + + uint64 Properties(uint64 props) const { + return (props & kSetArcProperties) | kOEpsilons; + } +}; + +// Mapper that returns its input with final states redirected to a single +// super-final state. +template +class SuperFinalMapper { + public: + using FromArc = A; + using ToArc = A; + using Label = typename FromArc::Label; + using Weight = typename FromArc::Weight;; + + // Arg allows setting super-final label. + explicit SuperFinalMapper(Label final_label = 0) + : final_label_(final_label) {} + + ToArc operator()(const FromArc &arc) const { + // Super-final arc. + if (arc.nextstate == kNoStateId && arc.weight != Weight::Zero()) { + return ToArc(final_label_, final_label_, arc.weight, kNoStateId); + } else { + return arc; + } + } + + constexpr MapFinalAction FinalAction() const { + return MAP_REQUIRE_SUPERFINAL; + } + + constexpr MapSymbolsAction InputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + constexpr MapSymbolsAction OutputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + uint64 Properties(uint64 props) const { + if (final_label_ == 0) { + return props & kAddSuperFinalProperties; + } else { + return props & kAddSuperFinalProperties & + kILabelInvariantProperties & kOLabelInvariantProperties; + } + } + + private: + Label final_label_; +}; + +// Mapper that leaves labels and nextstate unchanged and constructs a new weight +// from the underlying value of the arc weight. If no weight converter is +// explictly specified, requires that there is a WeightConvert class +// specialization that converts the weights. +template > +class WeightConvertMapper { + public: + using FromArc = A; + using ToArc = B; + using Converter = C; + using FromWeight = typename FromArc::Weight; + using ToWeight = typename ToArc::Weight; + + explicit WeightConvertMapper(const Converter &c = Converter()) + : convert_weight_(c) {} + + ToArc operator()(const FromArc &arc) const { + return ToArc(arc.ilabel, arc.olabel, convert_weight_(arc.weight), + arc.nextstate); + } + + constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; } + + constexpr MapSymbolsAction InputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + constexpr MapSymbolsAction OutputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + uint64 Properties(uint64 props) const { return props; } + + private: + Converter convert_weight_; +}; + +// Non-precision-changing weight conversions; consider using more efficient +// Cast method instead. + +using StdToLogMapper = WeightConvertMapper; + +using LogToStdMapper = WeightConvertMapper; + +// Precision-changing weight conversions. + +using StdToLog64Mapper = WeightConvertMapper; + +using LogToLog64Mapper = WeightConvertMapper; + +using Log64ToStdMapper = WeightConvertMapper; + +using Log64ToLogMapper = WeightConvertMapper; + +// Mapper from A to GallicArc. +template +class ToGallicMapper { + public: + using FromArc = A; + using ToArc = GallicArc; + + using SW = StringWeight; + using AW = typename FromArc::Weight; + using GW = typename ToArc::Weight; + + ToArc operator()(const FromArc &arc) const { + // Super-final arc. + if (arc.nextstate == kNoStateId && arc.weight != AW::Zero()) { + return ToArc(0, 0, GW(SW::One(), arc.weight), kNoStateId); + // Super-non-final arc. + } else if (arc.nextstate == kNoStateId) { + return ToArc(0, 0, GW::Zero(), kNoStateId); + // Epsilon label. + } else if (arc.olabel == 0) { + return ToArc(arc.ilabel, arc.ilabel, GW(SW::One(), arc.weight), + arc.nextstate); + // Regular label. + } else { + return ToArc(arc.ilabel, arc.ilabel, GW(SW(arc.olabel), arc.weight), + arc.nextstate); + } + } + + constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; } + + constexpr MapSymbolsAction InputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + constexpr MapSymbolsAction OutputSymbolsAction() const { + return MAP_CLEAR_SYMBOLS; + } + + uint64 Properties(uint64 props) const { + return ProjectProperties(props, true) & kWeightInvariantProperties; + } +}; + +// Mapper from GallicArc to A. +template +class FromGallicMapper { + public: + using FromArc = GallicArc; + using ToArc = A; + + using Label = typename ToArc::Label; + using AW = typename ToArc::Weight; + using GW = typename FromArc::Weight; + + explicit FromGallicMapper(Label superfinal_label = 0) + : superfinal_label_(superfinal_label), error_(false) {} + + ToArc operator()(const FromArc &arc) const { + // 'Super-non-final' arc. + if (arc.nextstate == kNoStateId && arc.weight == GW::Zero()) { + return A(arc.ilabel, 0, AW::Zero(), kNoStateId); + } + Label l = kNoLabel; + AW weight; + if (!Extract(arc.weight, &weight, &l) || arc.ilabel != arc.olabel) { + FSTERROR() << "FromGallicMapper: Unrepresentable weight: " << arc.weight + << " for arc with ilabel = " << arc.ilabel + << ", olabel = " << arc.olabel + << ", nextstate = " << arc.nextstate; + error_ = true; + } + if (arc.ilabel == 0 && l != 0 && arc.nextstate == kNoStateId) { + return ToArc(superfinal_label_, l, weight, arc.nextstate); + } else { + return ToArc(arc.ilabel, l, weight, arc.nextstate); + } + } + + constexpr MapFinalAction FinalAction() const { return MAP_ALLOW_SUPERFINAL; } + + constexpr MapSymbolsAction InputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + constexpr MapSymbolsAction OutputSymbolsAction() const { + return MAP_CLEAR_SYMBOLS; + } + + uint64 Properties(uint64 inprops) const { + uint64 outprops = inprops & kOLabelInvariantProperties & + kWeightInvariantProperties & kAddSuperFinalProperties; + if (error_) outprops |= kError; + return outprops; + } + + private: + template + static bool Extract(const GallicWeight &gallic_weight, + typename A::Weight *weight, typename A::Label *label) { + using GW = StringWeight; + const GW &w1 = gallic_weight.Value1(); + const AW &w2 = gallic_weight.Value2(); + typename GW::Iterator iter1(w1); + const Label l = w1.Size() == 1 ? iter1.Value() : 0; + if (l == kStringInfinity || l == kStringBad || w1.Size() > 1) return false; + *label = l; + *weight = w2; + return true; + } + + static bool Extract(const GallicWeight &gallic_weight, + typename A::Weight *weight, typename A::Label *label) { + if (gallic_weight.Size() > 1) return false; + if (gallic_weight.Size() == 0) { + *label = 0; + *weight = A::Weight::Zero(); + return true; + } + return Extract(gallic_weight.Back(), weight, label); + } + + const Label superfinal_label_; + mutable bool error_; +}; + +// Mapper from GallicArc to A. +template +class GallicToNewSymbolsMapper { + public: + using FromArc = GallicArc; + using ToArc = A; + + using Label = typename ToArc::Label; + using StateId = typename ToArc::StateId; + using AW = typename ToArc::Weight; + using GW = typename FromArc::Weight; + using SW = StringWeight; + + explicit GallicToNewSymbolsMapper(MutableFst *fst) + : fst_(fst), + lmax_(0), + osymbols_(fst->OutputSymbols()), + isymbols_(nullptr), + error_(false) { + fst_->DeleteStates(); + state_ = fst_->AddState(); + fst_->SetStart(state_); + fst_->SetFinal(state_, AW::One()); + if (osymbols_) { + string name = osymbols_->Name() + "_from_gallic"; + fst_->SetInputSymbols(new SymbolTable(name)); + isymbols_ = fst_->MutableInputSymbols(); + const int64 zero = 0; + isymbols_->AddSymbol(osymbols_->Find(zero), 0); + } else { + fst_->SetInputSymbols(nullptr); + } + } + + ToArc operator()(const FromArc &arc) { + // Super-non-final arc. + if (arc.nextstate == kNoStateId && arc.weight == GW::Zero()) { + return ToArc(arc.ilabel, 0, AW::Zero(), kNoStateId); + } + SW w1 = arc.weight.Value1(); + AW w2 = arc.weight.Value2(); + Label l; + if (w1.Size() == 0) { + l = 0; + } else { + auto insert_result = map_.insert(std::make_pair(w1, kNoLabel)); + if (!insert_result.second) { + l = insert_result.first->second; + } else { + l = ++lmax_; + insert_result.first->second = l; + StringWeightIterator iter1(w1); + StateId n; + string s; + for (size_t i = 0, p = state_; i < w1.Size(); + ++i, iter1.Next(), p = n) { + n = i == w1.Size() - 1 ? state_ : fst_->AddState(); + fst_->AddArc(p, ToArc(i ? 0 : l, iter1.Value(), AW::One(), n)); + if (isymbols_) { + if (i) s = s + "_"; + s = s + osymbols_->Find(iter1.Value()); + } + } + if (isymbols_) isymbols_->AddSymbol(s, l); + } + } + if (l == kStringInfinity || l == kStringBad || arc.ilabel != arc.olabel) { + FSTERROR() << "GallicToNewSymbolMapper: Unrepresentable weight: " << l; + error_ = true; + } + return ToArc(arc.ilabel, l, w2, arc.nextstate); + } + + constexpr MapFinalAction FinalAction() const { return MAP_ALLOW_SUPERFINAL; } + + constexpr MapSymbolsAction InputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + constexpr MapSymbolsAction OutputSymbolsAction() const { + return MAP_CLEAR_SYMBOLS; + } + + uint64 Properties(uint64 inprops) const { + uint64 outprops = inprops & kOLabelInvariantProperties & + kWeightInvariantProperties & kAddSuperFinalProperties; + if (error_) outprops |= kError; + return outprops; + } + + private: + class StringKey { + public: + size_t operator()(const SW &x) const { return x.Hash(); } + }; + + using Map = std::unordered_map; + + MutableFst *fst_; + Map map_; + Label lmax_; + StateId state_; + const SymbolTable *osymbols_; + SymbolTable *isymbols_; + mutable bool error_; +}; + +// TODO(kbg): Add common base class for those mappers which do nothing except +// mutate their weights. + +// Mapper to add a constant to all weights. +template +class PlusMapper { + public: + using FromArc = A; + using ToArc = A; + using Weight = typename FromArc::Weight; + + explicit PlusMapper(Weight weight) : weight_(std::move(weight)) {} + + ToArc operator()(const FromArc &arc) const { + if (arc.weight == Weight::Zero()) return arc; + return ToArc(arc.ilabel, arc.olabel, Plus(arc.weight, weight_), + arc.nextstate); + } + + constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; } + + constexpr MapSymbolsAction InputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + constexpr MapSymbolsAction OutputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + uint64 Properties(uint64 props) const { + return props & kWeightInvariantProperties; + } + + private: + const Weight weight_; +}; + +// Mapper to (right) multiply a constant to all weights. +template +class TimesMapper { + public: + using FromArc = A; + using ToArc = A; + using Weight = typename FromArc::Weight; + + explicit TimesMapper(Weight weight) : weight_(std::move(weight)) {} + + ToArc operator()(const FromArc &arc) const { + if (arc.weight == Weight::Zero()) return arc; + return ToArc(arc.ilabel, arc.olabel, Times(arc.weight, weight_), + arc.nextstate); + } + + constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; } + + constexpr MapSymbolsAction InputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + constexpr MapSymbolsAction OutputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + uint64 Properties(uint64 props) const { + return props & kWeightInvariantProperties; + } + + private: + const Weight weight_; +}; + +// Mapper to take all weights to a constant power. The power argument is stored +// as a double, so if there is a floating-point power implementation for this +// weight type, it will take precedence. Otherwise, the power argument's 53 bits +// of integer precision will be implicitly converted to a size_t and the default +// power implementation (iterated multiplication) will be used instead. +template +class PowerMapper { + public: + using FromArc = A; + using ToArc = A; + using Weight = typename FromArc::Weight; + + explicit PowerMapper(double power) : power_(power) {} + + ToArc operator()(const FromArc &arc) const { + return ToArc(arc.ilabel, arc.olabel, Power(arc.weight, power_), + arc.nextstate); + } + + constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; } + + constexpr MapSymbolsAction InputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + constexpr MapSymbolsAction OutputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + uint64 Properties(uint64 props) const { + return props & kWeightInvariantProperties; + } + + private: + const double power_; +}; + +// Mapper to reciprocate all non-Zero() weights. +template +class InvertWeightMapper { + public: + using FromArc = A; + using ToArc = A; + using Weight = typename FromArc::Weight; + + ToArc operator()(const FromArc &arc) const { + if (arc.weight == Weight::Zero()) return arc; + return ToArc(arc.ilabel, arc.olabel, Divide(Weight::One(), arc.weight), + arc.nextstate); + } + + constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; } + + constexpr MapSymbolsAction InputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + constexpr MapSymbolsAction OutputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + uint64 Properties(uint64 props) const { + return props & kWeightInvariantProperties; + } +}; + +// Mapper to map all non-Zero() weights to One(). +template +class RmWeightMapper { + public: + using FromArc = A; + using ToArc = B; + using FromWeight = typename FromArc::Weight; + using ToWeight = typename ToArc::Weight; + + ToArc operator()(const FromArc &arc) const { + return ToArc(arc.ilabel, arc.olabel, + arc.weight != FromWeight::Zero() ? + ToWeight::One() : ToWeight::Zero(), + arc.nextstate); + } + + constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; } + + constexpr MapSymbolsAction InputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + constexpr MapSymbolsAction OutputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + uint64 Properties(uint64 props) const { + return (props & kWeightInvariantProperties) | kUnweighted; + } +}; + +// Mapper to quantize all weights. +template +class QuantizeMapper { + public: + using FromArc = A; + using ToArc = B; + using FromWeight = typename FromArc::Weight; + using ToWeight = typename ToArc::Weight; + + QuantizeMapper() : delta_(kDelta) {} + + explicit QuantizeMapper(float d) : delta_(d) {} + + ToArc operator()(const FromArc &arc) const { + return ToArc(arc.ilabel, arc.olabel, arc.weight.Quantize(delta_), + arc.nextstate); + } + + constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; } + + constexpr MapSymbolsAction InputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + constexpr MapSymbolsAction OutputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + uint64 Properties(uint64 props) const { + return props & kWeightInvariantProperties; + } + + private: + const float delta_; +}; + +// Mapper from A to B under the assumption: +// +// B::Weight = A::Weight::ReverseWeight +// B::Label == A::Label +// B::StateId == A::StateId +// +// The weight is reversed, while the label and nextstate are preserved. +template +class ReverseWeightMapper { + public: + using FromArc = A; + using ToArc = B; + + ToArc operator()(const FromArc &arc) const { + return ToArc(arc.ilabel, arc.olabel, arc.weight.Reverse(), arc.nextstate); + } + + constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; } + + constexpr MapSymbolsAction InputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + constexpr MapSymbolsAction OutputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + uint64 Properties(uint64 props) const { return props; } +}; + +} // namespace fst + +#endif // FST_ARC_MAP_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/arc.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/arc.h new file mode 100644 index 0000000000..7bd0c47ae6 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/arc.h @@ -0,0 +1,310 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Commonly used FST arc types. + +#ifndef FST_ARC_H_ +#define FST_ARC_H_ + +#include +#include +#include + + +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace fst { + +template +struct ArcTpl { + public: + using Weight = W; + using Label = int; + using StateId = int; + + Label ilabel; + Label olabel; + Weight weight; + StateId nextstate; + + ArcTpl() {} + + ArcTpl(Label ilabel, Label olabel, Weight weight, StateId nextstate) + : ilabel(ilabel), + olabel(olabel), + weight(std::move(weight)), + nextstate(nextstate) {} + + static const string &Type() { + static const string *const type = + new string(Weight::Type() == "tropical" ? "standard" : Weight::Type()); + return *type; + } +}; + +using StdArc = ArcTpl; +using LogArc = ArcTpl; +using Log64Arc = ArcTpl; +using SignedLogArc = ArcTpl; +using SignedLog64Arc = ArcTpl; +using MinMaxArc = ArcTpl; + +// Arc with integer labels and state IDs and string weights. +template +struct StringArc { + public: + using Label = int; + using Weight = StringWeight; + using StateId = int; + + Label ilabel; + Label olabel; + Weight weight; + StateId nextstate; + + StringArc() = default; + + StringArc(Label ilabel, Label olabel, Weight weight, StateId nextstate) + : ilabel(ilabel), + olabel(olabel), + weight(std::move(weight)), + nextstate(nextstate) {} + + static const string &Type() { + static const string *const type = + new string(S == STRING_LEFT + ? "left_standard_string" + : (S == STRING_RIGHT ? "right_standard_string" + : "restricted_standard_string")); + return *type; + } +}; + +// Arc with label and state Id type the same as template arg and with +// weights over the Gallic semiring w.r.t the output labels and weights of A. +template +struct GallicArc { + using Arc = A; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = GallicWeight; + + Label ilabel; + Label olabel; + Weight weight; + StateId nextstate; + + GallicArc() = default; + + GallicArc(Label ilabel, Label olabel, Weight weight, StateId nextstate) + : ilabel(ilabel), + olabel(olabel), + weight(std::move(weight)), + nextstate(nextstate) {} + + explicit GallicArc(const Arc &arc) + : ilabel(arc.ilabel), olabel(arc.ilabel), weight(arc.olabel, arc.weight), + nextstate(arc.nextstate) {} + + static const string &Type() { + static const string *const type = + new string( + (G == GALLIC_LEFT + ? "left_gallic_" + : (G == GALLIC_RIGHT + ? "right_gallic_" + : (G == GALLIC_RESTRICT + ? "restricted_gallic_" + : (G == GALLIC_MIN + ? "min_gallic_" : "gallic_")))) + + Arc::Type()); + return *type; + } +}; + +// Arc with the reverse of the weight found in its template arg. +template +struct ReverseArc { + using Arc = A; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using AWeight = typename Arc::Weight; + using Weight = typename AWeight::ReverseWeight; + + Label ilabel; + Label olabel; + Weight weight; + StateId nextstate; + + ReverseArc() = default; + + ReverseArc(Label ilabel, Label olabel, Weight weight, StateId nextstate) + : ilabel(ilabel), + olabel(olabel), + weight(std::move(weight)), + nextstate(nextstate) {} + + static const string &Type() { + static const string *const type = new string("reverse_" + Arc::Type()); + return *type; + } +}; + +// Arc with integer labels and state IDs and lexicographic weights. +template +struct LexicographicArc { + using Label = int; + using StateId = int; + using Weight = LexicographicWeight; + + Label ilabel; + Label olabel; + Weight weight; + StateId nextstate; + + LexicographicArc() = default; + + LexicographicArc(Label ilabel, Label olabel, Weight weight, StateId nextstate) + : ilabel(ilabel), + olabel(olabel), + weight(std::move(weight)), + nextstate(nextstate) {} + + static const string &Type() { + static const string *const type = new string(Weight::Type()); + return *type; + } +}; + +// Arc with integer labels and state IDs and product weights. +template +struct ProductArc { + using Label = int; + using StateId = int; + using Weight = ProductWeight; + + Label ilabel; + Label olabel; + Weight weight; + StateId nextstate; + + ProductArc() = default; + + ProductArc(Label ilabel, Label olabel, Weight weight, StateId nextstate) + : ilabel(ilabel), + olabel(olabel), + weight(std::move(weight)), + nextstate(nextstate) {} + + static const string &Type() { + static const string *const type = new string(Weight::Type()); + return *type; + } +}; + +// Arc with label and state ID type the same as first template argument and with +// weights over the n-th Cartesian power of the weight type of the template +// argument. +template +struct PowerArc { + using Arc = A; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = PowerWeight; + + Label ilabel; + Label olabel; + Weight weight; + StateId nextstate; + + PowerArc() = default; + + PowerArc(Label ilabel, Label olabel, Weight weight, StateId nextstate) + : ilabel(ilabel), + olabel(olabel), + weight(std::move(weight)), + nextstate(nextstate) {} + + static const string &Type() { + static const string *const type = + new string(Arc::Type() + "_^" + std::to_string(N)); + return *type; + } +}; + +// Arc with label and state ID type the same as first template argument and with +// weights over the arbitrary Cartesian power of the weight type. +template +struct SparsePowerArc { + using Arc = A; + using Label = typename Arc::Label; + using StateId = typename Arc::Label; + using Weight = SparsePowerWeight; + + Label ilabel; + Label olabel; + Weight weight; + StateId nextstate; + + SparsePowerArc() = default; + + SparsePowerArc(Label ilabel, Label olabel, Weight weight, StateId nextstate) + : ilabel(ilabel), + olabel(olabel), + weight(std::move(weight)), + nextstate(nextstate) {} + + static const string &Type() { + static const string *const type = [] { + string type = Arc::Type() + "_^n"; + if (sizeof(K) != sizeof(uint32)) { + type += "_" + std::to_string(CHAR_BIT * sizeof(K)); + } + return new string(type); + }(); + return *type; + } +}; + +// Arc with label and state ID type the same as first template argument and with +// expectation weight over the first template argument's weight type and the +// second template argument. +template +struct ExpectationArc { + using Arc = A; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using X1 = typename Arc::Weight; + using Weight = ExpectationWeight; + + Label ilabel; + Label olabel; + Weight weight; + StateId nextstate; + + ExpectationArc() = default; + + ExpectationArc(Label ilabel, Label olabel, Weight weight, StateId nextstate) + : ilabel(ilabel), + olabel(olabel), + weight(std::move(weight)), + nextstate(nextstate) {} + + static const string &Type() { + static const string *const type = + new string("expectation_" + Arc::Type() + "_" + X2::Type()); + return *type; + } +}; + +} // namespace fst + +#endif // FST_ARC_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/arcfilter.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/arcfilter.h new file mode 100644 index 0000000000..598e543f33 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/arcfilter.h @@ -0,0 +1,93 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Function objects to restrict which arcs are traversed in an FST. + +#ifndef FST_ARCFILTER_H_ +#define FST_ARCFILTER_H_ + + +#include +#include + + +namespace fst { + +// True for all arcs. +template +class AnyArcFilter { + public: + bool operator()(const Arc &arc) const { return true; } +}; + +// True for (input/output) epsilon arcs. +template +class EpsilonArcFilter { + public: + bool operator()(const Arc &arc) const { + return arc.ilabel == 0 && arc.olabel == 0; + } +}; + +// True for input epsilon arcs. +template +class InputEpsilonArcFilter { + public: + bool operator()(const Arc &arc) const { return arc.ilabel == 0; } +}; + +// True for output epsilon arcs. +template +class OutputEpsilonArcFilter { + public: + bool operator()(const Arc &arc) const { return arc.olabel == 0; } +}; + +// True if specified label matches (doesn't match) when keep_match is +// true (false). +template +class LabelArcFilter { + public: + using Label = typename Arc::Label; + + explicit LabelArcFilter(Label label, bool match_input = true, + bool keep_match = true) + : label_(label), match_input_(match_input), keep_match_(keep_match) {} + + bool operator()(const Arc &arc) const { + const bool match = (match_input_ ? arc.ilabel : arc.olabel) == label_; + return keep_match_ ? match : !match; + } + + private: + const Label label_; + const bool match_input_; + const bool keep_match_; +}; + +// True if specified labels match (don't match) when keep_match is true (false). +template +class MultiLabelArcFilter { + public: + using Label = typename Arc::Label; + + explicit MultiLabelArcFilter(bool match_input = true, bool keep_match = true) + : match_input_(match_input), keep_match_(keep_match) {} + + bool operator()(const Arc &arc) const { + const Label label = match_input_ ? arc.ilabel : arc.olabel; + const bool match = labels_.Find(label) != labels_.End(); + return keep_match_ ? match : !match; + } + + void AddLabel(Label label) { labels_.Insert(label); } + + private: + CompactSet labels_; + const bool match_input_; + const bool keep_match_; +}; + +} // namespace fst + +#endif // FST_ARCFILTER_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/arcsort.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/arcsort.h new file mode 100644 index 0000000000..b159757a2c --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/arcsort.h @@ -0,0 +1,211 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Functions and classes to sort arcs in an FST. + +#ifndef FST_ARCSORT_H_ +#define FST_ARCSORT_H_ + +#include +#include +#include + +#include +#include +#include + + +namespace fst { + +template +class ArcSortMapper { + public: + using FromArc = Arc; + using ToArc = Arc; + + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + ArcSortMapper(const Fst &fst, const Compare &comp) + : fst_(fst), comp_(comp), i_(0) {} + + // Allows updating Fst argument; pass only if changed. + ArcSortMapper(const ArcSortMapper &mapper, + const Fst *fst = nullptr) + : fst_(fst ? *fst : mapper.fst_), comp_(mapper.comp_), i_(0) {} + + StateId Start() { return fst_.Start(); } + + Weight Final(StateId s) const { return fst_.Final(s); } + + void SetState(StateId s) { + i_ = 0; + arcs_.clear(); + arcs_.reserve(fst_.NumArcs(s)); + for (ArcIterator> aiter(fst_, s); !aiter.Done(); aiter.Next()) { + arcs_.push_back(aiter.Value()); + } + std::sort(arcs_.begin(), arcs_.end(), comp_); + } + + bool Done() const { return i_ >= arcs_.size(); } + + const Arc &Value() const { return arcs_[i_]; } + + void Next() { ++i_; } + + MapSymbolsAction InputSymbolsAction() const { return MAP_COPY_SYMBOLS; } + + MapSymbolsAction OutputSymbolsAction() const { return MAP_COPY_SYMBOLS; } + + uint64 Properties(uint64 props) const { return comp_.Properties(props); } + + private: + const Fst &fst_; + const Compare &comp_; + std::vector arcs_; + ssize_t i_; // current arc position + + ArcSortMapper &operator=(const ArcSortMapper &) = delete; +}; + +// Sorts the arcs in an FST according to function object 'comp' of type Compare. +// This version modifies its input. Comparison function objects ILabelCompare +// and OLabelCompare are provided by the library. In general, Compare must meet +// the requirements for a comparison function object (e.g., similar to those +// used by std::sort). It must also have a member Properties(uint64) that +// specifies the known properties of the sorted FST; it takes as argument the +// input FST's known properties before the sort. +// +// Complexity: +// +// - Time: O(v d log d) +// - Space: O(d) +// +// where v = # of states and d = maximum out-degree. +template +void ArcSort(MutableFst *fst, Compare comp) { + ArcSortMapper mapper(*fst, comp); + StateMap(fst, mapper); +} + +using ArcSortFstOptions = CacheOptions; + +// Sorts the arcs in an FST according to function object 'comp' of type Compare. +// This version is a delayed FST. Comparsion function objects ILabelCompare and +// OLabelCompare are provided by the library. In general, Compare must meet the +// requirements for a comparision function object (e.g., similar to those +// used by std::sort). It must also have a member Properties(uint64) that +// specifies the known properties of the sorted FST; it takes as argument the +// input FST's known properties. +// +// Complexity: +// +// - Time: O(v d log d) +// - Space: O(d) +// +// where v = # of states visited, d = maximum out-degree of states visited. +// Constant time and space to visit an input state is assumed and exclusive of +// caching. +template +class ArcSortFst : public StateMapFst> { + using StateMapFst>::GetImpl; + + public: + using StateId = typename Arc::StateId; + using Mapper = ArcSortMapper; + + ArcSortFst(const Fst &fst, const Compare &comp) + : StateMapFst(fst, + ArcSortMapper(fst, comp)) {} + + ArcSortFst(const Fst &fst, const Compare &comp, + const ArcSortFstOptions &opts) + : StateMapFst(fst, Mapper(fst, comp), opts) {} + + // See Fst<>::Copy() for doc. + ArcSortFst(const ArcSortFst &fst, bool safe = false) + : StateMapFst(fst, safe) {} + + // Gets a copy of this ArcSortFst. See Fst<>::Copy() for further doc. + ArcSortFst *Copy(bool safe = false) const override { + return new ArcSortFst(*this, safe); + } + + size_t NumArcs(StateId s) const override { + return GetImpl()->GetFst()->NumArcs(s); + } + + size_t NumInputEpsilons(StateId s) const override { + return GetImpl()->GetFst()->NumInputEpsilons(s); + } + + size_t NumOutputEpsilons(StateId s) const override { + return GetImpl()->GetFst()->NumOutputEpsilons(s); + } +}; + +// Specialization for ArcSortFst. +template +class StateIterator> + : public StateIterator>> { + public: + explicit StateIterator(const ArcSortFst &fst) + : StateIterator>>(fst) { + } +}; + +// Specialization for ArcSortFst. +template +class ArcIterator> + : public ArcIterator>> { + public: + ArcIterator(const ArcSortFst &fst, typename Arc::StateId s) + : ArcIterator>>(fst, + s) {} +}; + +// Compare class for comparing input labels of arcs. +template +class ILabelCompare { + public: + ILabelCompare() {} + + bool operator()(const Arc &arc1, const Arc &arc2) const { + return arc1.ilabel < arc2.ilabel; + } + + uint64 Properties(uint64 props) const { + return (props & kArcSortProperties) | kILabelSorted | + (props & kAcceptor ? kOLabelSorted : 0); + } +}; + +// Compare class for comparing output labels of arcs. +template +class OLabelCompare { + public: + OLabelCompare() {} + + bool operator()(const Arc &arc1, const Arc &arc2) const { + return arc1.olabel < arc2.olabel; + } + + uint64 Properties(uint64 props) const { + return (props & kArcSortProperties) | kOLabelSorted | + (props & kAcceptor ? kILabelSorted : 0); + } +}; + +// Useful aliases when using StdArc. + +template +using StdArcSortFst = ArcSortFst; + +using StdILabelCompare = ILabelCompare; + +using StdOLabelCompare = OLabelCompare; + +} // namespace fst + +#endif // FST_ARCSORT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/bi-table.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/bi-table.h new file mode 100644 index 0000000000..3414b1d379 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/bi-table.h @@ -0,0 +1,473 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Classes for representing a bijective mapping between an arbitrary entry +// of type T and a signed integral ID. + +#ifndef FST_BI_TABLE_H_ +#define FST_BI_TABLE_H_ + +#include +#include +#include +#include +#include +#include + +#include +#include + +namespace fst { + +// Bitables model bijective mappings between entries of an arbitrary type T and +// an signed integral ID of type I. The IDs are allocated starting from 0 in +// order. +// +// template +// class BiTable { +// public: +// +// // Required constructors. +// BiTable(); +// +// // Looks up integer ID from entry. If it doesn't exist and insert +// / is true, adds it; otherwise, returns -1. +// I FindId(const T &entry, bool insert = true); +// +// // Looks up entry from integer ID. +// const T &FindEntry(I) const; +// +// // Returns number of stored entries. +// I Size() const; +// }; + +// An implementation using a hash map for the entry to ID mapping. H is the +// hash function and E is the equality function. If passed to the constructor, +// ownership is given to this class. +template > +class HashBiTable { + public: + // Reserves space for table_size elements. If passing H and E to the + // constructor, this class owns them. + explicit HashBiTable(size_t table_size = 0, H *h = nullptr, E *e = nullptr) : + hash_func_(h ? h : new H()), hash_equal_(e ? e : new E()), + entry2id_(table_size, *hash_func_, *hash_equal_) { + if (table_size) id2entry_.reserve(table_size); + } + + HashBiTable(const HashBiTable &table) + : hash_func_(new H(*table.hash_func_)), + hash_equal_(new E(*table.hash_equal_)), + entry2id_(table.entry2id_.begin(), table.entry2id_.end(), + table.entry2id_.size(), *hash_func_, *hash_equal_), + id2entry_(table.id2entry_) {} + + I FindId(const T &entry, bool insert = true) { + if (!insert) { + const auto it = entry2id_.find(entry); + return it == entry2id_.end() ? -1 : it->second - 1; + } + I &id_ref = entry2id_[entry]; + if (id_ref == 0) { // T not found; stores and assigns a new ID. + id2entry_.push_back(entry); + id_ref = id2entry_.size(); + } + return id_ref - 1; // NB: id_ref = ID + 1. + } + + const T &FindEntry(I s) const { return id2entry_[s]; } + + I Size() const { return id2entry_.size(); } + + // TODO(riley): Add fancy clear-to-size, as in CompactHashBiTable. + void Clear() { + entry2id_.clear(); + id2entry_.clear(); + } + + private: + std::unique_ptr hash_func_; + std::unique_ptr hash_equal_; + std::unordered_map entry2id_; + std::vector id2entry_; +}; + +// Enables alternative hash set representations below. +enum HSType { HS_STL = 0, HS_DENSE = 1, HS_SPARSE = 2, HS_FLAT = 3 }; + +// Default hash set is STL hash_set. +template +struct HashSet : public std::unordered_set> { + explicit HashSet(size_t n = 0, const H &h = H(), const E &e = E()) + : std::unordered_set>(n, h, e) {} + + void rehash(size_t n) {} +}; + +// An implementation using a hash set for the entry to ID mapping. The hash set +// holds keys which are either the ID or kCurrentKey. These keys can be mapped +// to entries either by looking up in the entry vector or, if kCurrentKey, in +// current_entry_. The hash and key equality functions map to entries first. H +// is the hash function and E is the equality function. If passed to the +// constructor, ownership is given to this class. +template , + HSType HS = HS_FLAT> +class CompactHashBiTable { + public: + friend class HashFunc; + friend class HashEqual; + + // Reserves space for table_size elements. If passing H and E to the + // constructor, this class owns them. + explicit CompactHashBiTable(size_t table_size = 0, H *h = nullptr, + E *e = nullptr) : + hash_func_(h ? h : new H()), hash_equal_(e ? e : new E()), + compact_hash_func_(*this), compact_hash_equal_(*this), + keys_(table_size, compact_hash_func_, compact_hash_equal_) { + if (table_size) id2entry_.reserve(table_size); + } + + CompactHashBiTable(const CompactHashBiTable &table) + : hash_func_(new H(*table.hash_func_)), + hash_equal_(new E(*table.hash_equal_)), + compact_hash_func_(*this), compact_hash_equal_(*this), + keys_(table.keys_.size(), compact_hash_func_, compact_hash_equal_), + id2entry_(table.id2entry_) { + keys_.insert(table.keys_.begin(), table.keys_.end()); + } + + I FindId(const T &entry, bool insert = true) { + current_entry_ = &entry; + if (insert) { + auto result = keys_.insert(kCurrentKey); + if (!result.second) return *result.first; // Already exists. + // Overwrites kCurrentKey with a new key value; this is safe because it + // doesn't affect hashing or equality testing. + I key = id2entry_.size(); + const_cast(*result.first) = key; + id2entry_.push_back(entry); + return key; + } + const auto it = keys_.find(kCurrentKey); + return it == keys_.end() ? -1 : *it; + } + + const T &FindEntry(I s) const { return id2entry_[s]; } + + I Size() const { return id2entry_.size(); } + + // Clears content; with argument, erases last n IDs. + void Clear(ssize_t n = -1) { + if (n < 0 || n >= id2entry_.size()) { // Clears completely. + keys_.clear(); + id2entry_.clear(); + } else if (n == id2entry_.size() - 1) { // Leaves only key 0. + const T entry = FindEntry(0); + keys_.clear(); + id2entry_.clear(); + FindId(entry, true); + } else { + while (n-- > 0) { + I key = id2entry_.size() - 1; + keys_.erase(key); + id2entry_.pop_back(); + } + keys_.rehash(0); + } + } + + private: + static constexpr I kCurrentKey = -1; + static constexpr I kEmptyKey = -2; + static constexpr I kDeletedKey = -3; + + class HashFunc { + public: + explicit HashFunc(const CompactHashBiTable &ht) : ht_(&ht) {} + + size_t operator()(I k) const { + if (k >= kCurrentKey) { + return (*ht_->hash_func_)(ht_->Key2Entry(k)); + } else { + return 0; + } + } + + private: + const CompactHashBiTable *ht_; + }; + + class HashEqual { + public: + explicit HashEqual(const CompactHashBiTable &ht) : ht_(&ht) {} + + bool operator()(I k1, I k2) const { + if (k1 == k2) { + return true; + } else if (k1 >= kCurrentKey && k2 >= kCurrentKey) { + return (*ht_->hash_equal_)(ht_->Key2Entry(k1), ht_->Key2Entry(k2)); + } else { + return false; + } + } + + private: + const CompactHashBiTable *ht_; + }; + + using KeyHashSet = HashSet; + + const T &Key2Entry(I k) const { + if (k == kCurrentKey) { + return *current_entry_; + } else { + return id2entry_[k]; + } + } + + std::unique_ptr hash_func_; + std::unique_ptr hash_equal_; + HashFunc compact_hash_func_; + HashEqual compact_hash_equal_; + KeyHashSet keys_; + std::vector id2entry_; + const T *current_entry_; +}; + +template +constexpr I CompactHashBiTable::kCurrentKey; + +template +constexpr I CompactHashBiTable::kEmptyKey; + +template +constexpr I CompactHashBiTable::kDeletedKey; + +// An implementation using a vector for the entry to ID mapping. It is passed a +// function object FP that should fingerprint entries uniquely to an integer +// that can used as a vector index. Normally, VectorBiTable constructs the FP +// object. The user can instead pass in this object; in that case, VectorBiTable +// takes its ownership. +template +class VectorBiTable { + public: + // Reserves table_size cells of space. If passing FP argument to the + // constructor, this class owns it. + explicit VectorBiTable(FP *fp = nullptr, size_t table_size = 0) : + fp_(fp ? fp : new FP()) { + if (table_size) id2entry_.reserve(table_size); + } + + VectorBiTable(const VectorBiTable &table) + : fp_(new FP(*table.fp_)), fp2id_(table.fp2id_), + id2entry_(table.id2entry_) {} + + I FindId(const T &entry, bool insert = true) { + ssize_t fp = (*fp_)(entry); + if (fp >= fp2id_.size()) fp2id_.resize(fp + 1); + I &id_ref = fp2id_[fp]; + if (id_ref == 0) { // T not found. + if (insert) { // Stores and assigns a new ID. + id2entry_.push_back(entry); + id_ref = id2entry_.size(); + } else { + return -1; + } + } + return id_ref - 1; // NB: id_ref = ID + 1. + } + + const T &FindEntry(I s) const { return id2entry_[s]; } + + I Size() const { return id2entry_.size(); } + + const FP &Fingerprint() const { return *fp_; } + + private: + std::unique_ptr fp_; + std::vector fp2id_; + std::vector id2entry_; +}; + +// An implementation using a vector and a compact hash table. The selecting +// functor S returns true for entries to be hashed in the vector. The +// fingerprinting functor FP returns a unique fingerprint for each entry to be +// hashed in the vector (these need to be suitable for indexing in a vector). +// The hash functor H is used when hashing entry into the compact hash table. +// If passed to the constructor, ownership is given to this class. +template +class VectorHashBiTable { + public: + friend class HashFunc; + friend class HashEqual; + + explicit VectorHashBiTable(S *s, FP *fp, H *h, size_t vector_size = 0, + size_t entry_size = 0) + : selector_(s), fp_(fp), h_(h), hash_func_(*this), hash_equal_(*this), + keys_(0, hash_func_, hash_equal_) { + if (vector_size) fp2id_.reserve(vector_size); + if (entry_size) id2entry_.reserve(entry_size); + } + + VectorHashBiTable(const VectorHashBiTable &table) + : selector_(new S(table.s_)), fp_(new FP(*table.fp_)), + h_(new H(*table.h_)), id2entry_(table.id2entry_), + fp2id_(table.fp2id_), hash_func_(*this), hash_equal_(*this), + keys_(table.keys_.size(), hash_func_, hash_equal_) { + keys_.insert(table.keys_.begin(), table.keys_.end()); + } + + I FindId(const T &entry, bool insert = true) { + if ((*selector_)(entry)) { // Uses the vector if selector_(entry) == true. + uint64 fp = (*fp_)(entry); + if (fp2id_.size() <= fp) fp2id_.resize(fp + 1, 0); + if (fp2id_[fp] == 0) { // T not found. + if (insert) { // Stores and assigns a new ID. + id2entry_.push_back(entry); + fp2id_[fp] = id2entry_.size(); + } else { + return -1; + } + } + return fp2id_[fp] - 1; // NB: assoc_value = ID + 1. + } else { // Uses the hash table otherwise. + current_entry_ = &entry; + const auto it = keys_.find(kCurrentKey); + if (it == keys_.end()) { + if (insert) { + I key = id2entry_.size(); + id2entry_.push_back(entry); + keys_.insert(key); + return key; + } else { + return -1; + } + } else { + return *it; + } + } + } + + const T &FindEntry(I s) const { return id2entry_[s]; } + + I Size() const { return id2entry_.size(); } + + const S &Selector() const { return *selector_; } + + const FP &Fingerprint() const { return *fp_; } + + const H &Hash() const { return *h_; } + + private: + static constexpr I kCurrentKey = -1; + static constexpr I kEmptyKey = -2; + + class HashFunc { + public: + explicit HashFunc(const VectorHashBiTable &ht) : ht_(&ht) {} + + size_t operator()(I k) const { + if (k >= kCurrentKey) { + return (*(ht_->h_))(ht_->Key2Entry(k)); + } else { + return 0; + } + } + + private: + const VectorHashBiTable *ht_; + }; + + class HashEqual { + public: + explicit HashEqual(const VectorHashBiTable &ht) : ht_(&ht) {} + + bool operator()(I k1, I k2) const { + if (k1 >= kCurrentKey && k2 >= kCurrentKey) { + return ht_->Key2Entry(k1) == ht_->Key2Entry(k2); + } else { + return k1 == k2; + } + } + + private: + const VectorHashBiTable *ht_; + }; + + using KeyHashSet = HashSet; + + const T &Key2Entry(I k) const { + if (k == kCurrentKey) { + return *current_entry_; + } else { + return id2entry_[k]; + } + } + + std::unique_ptr selector_; // True if entry hashed into vector. + std::unique_ptr fp_; // Fingerprint used for hashing into vector. + std::unique_ptr h_; // Hash funcion used for hashing into hash_set. + + std::vector id2entry_; // Maps state IDs to entry. + std::vector fp2id_; // Maps entry fingerprints to IDs. + + // Compact implementation of the hash table mapping entries to state IDs + // using the hash function h_. + HashFunc hash_func_; + HashEqual hash_equal_; + KeyHashSet keys_; + const T *current_entry_; +}; + +template +constexpr I VectorHashBiTable::kCurrentKey; + +template +constexpr I VectorHashBiTable::kEmptyKey; + +// An implementation using a hash map for the entry to ID mapping. This version +// permits erasing of arbitrary states. The entry T must have == defined and +// its default constructor must produce a entry that will never be seen. F is +// the hash function. +template +class ErasableBiTable { + public: + ErasableBiTable() : first_(0) {} + + I FindId(const T &entry, bool insert = true) { + I &id_ref = entry2id_[entry]; + if (id_ref == 0) { // T not found. + if (insert) { // Stores and assigns a new ID. + id2entry_.push_back(entry); + id_ref = id2entry_.size() + first_; + } else { + return -1; + } + } + return id_ref - 1; // NB: id_ref = ID + 1. + } + + const T &FindEntry(I s) const { return id2entry_[s - first_]; } + + I Size() const { return id2entry_.size(); } + + void Erase(I s) { + auto &ref = id2entry_[s - first_]; + entry2id_.erase(ref); + ref = empty_entry_; + while (!id2entry_.empty() && id2entry_.front() == empty_entry_) { + id2entry_.pop_front(); + ++first_; + } + } + + private: + std::unordered_map entry2id_; + std::deque id2entry_; + const T empty_entry_; + I first_; // I of first element in the deque. +}; + +} // namespace fst + +#endif // FST_BI_TABLE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/cache.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/cache.h new file mode 100644 index 0000000000..45d158f5e5 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/cache.h @@ -0,0 +1,1277 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// An FST implementation that caches FST elements of a delayed computation. + +#ifndef FST_CACHE_H_ +#define FST_CACHE_H_ + +#include +#include +using std::unordered_map; +using std::unordered_multimap; +#include +#include + +#include +#include + +#include + + +DECLARE_bool(fst_default_cache_gc); +DECLARE_int64(fst_default_cache_gc_limit); + +namespace fst { + +// Options for controlling caching behavior; higher level than CacheImplOptions. +struct CacheOptions { + bool gc; // Enables GC. + size_t gc_limit; // Number of bytes allowed before GC. + + explicit CacheOptions(bool gc = FLAGS_fst_default_cache_gc, + size_t gc_limit = FLAGS_fst_default_cache_gc_limit) + : gc(gc), gc_limit(gc_limit) {} +}; + +// Options for controlling caching behavior, at a lower level than +// CacheOptions; templated on the cache store and allows passing the store. +template +struct CacheImplOptions { + bool gc; // Enables GC. + size_t gc_limit; // Number of bytes allowed before GC. + CacheStore *store; // Cache store. + bool own_store; // Should CacheImpl takes ownership of the store? + + explicit CacheImplOptions(bool gc = FLAGS_fst_default_cache_gc, + size_t gc_limit = FLAGS_fst_default_cache_gc_limit, + CacheStore *store = nullptr) + : gc(gc), gc_limit(gc_limit), store(store), own_store(true) {} + + explicit CacheImplOptions(const CacheOptions &opts) + : gc(opts.gc), gc_limit(opts.gc_limit), store(nullptr), own_store(true) {} +}; + +// Cache flags. +constexpr uint32 kCacheFinal = 0x0001; // Final weight has been cached. +constexpr uint32 kCacheArcs = 0x0002; // Arcs have been cached. +constexpr uint32 kCacheInit = 0x0004; // Initialized by GC. +constexpr uint32 kCacheRecent = 0x0008; // Visited since GC. +constexpr uint32 kCacheFlags = + kCacheFinal | kCacheArcs | kCacheInit | kCacheRecent; + +// Cache state, with arcs stored in a per-state std::vector. +template > +class CacheState { + public: + using Arc = A; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using ArcAllocator = M; + using StateAllocator = + typename ArcAllocator::template rebind>::other; + + // Provides STL allocator for arcs. + explicit CacheState(const ArcAllocator &alloc) + : final_(Weight::Zero()), + niepsilons_(0), + noepsilons_(0), + arcs_(alloc), + flags_(0), + ref_count_(0) {} + + CacheState(const CacheState &state, const ArcAllocator &alloc) + : final_(state.Final()), + niepsilons_(state.NumInputEpsilons()), + noepsilons_(state.NumOutputEpsilons()), + arcs_(state.arcs_.begin(), state.arcs_.end(), alloc), + flags_(state.Flags()), + ref_count_(0) {} + + void Reset() { + final_ = Weight::Zero(); + niepsilons_ = 0; + noepsilons_ = 0; + ref_count_ = 0; + flags_ = 0; + arcs_.clear(); + } + + Weight Final() const { return final_; } + + size_t NumInputEpsilons() const { return niepsilons_; } + + size_t NumOutputEpsilons() const { return noepsilons_; } + + size_t NumArcs() const { return arcs_.size(); } + + const Arc &GetArc(size_t n) const { return arcs_[n]; } + + // Used by the ArcIterator> efficient implementation. + const Arc *Arcs() const { return !arcs_.empty() ? &arcs_[0] : nullptr; } + + // Accesses flags; used by the caller. + uint32 Flags() const { return flags_; } + + // Accesses ref count; used by the caller. + int RefCount() const { return ref_count_; } + + void SetFinal(Weight weight) { final_ = std::move(weight); } + + void ReserveArcs(size_t n) { arcs_.reserve(n); } + + // Adds one arc at a time with all needed book-keeping; use PushArc and + // SetArcs for a more efficient alternative. + void AddArc(const Arc &arc) { + arcs_.push_back(arc); + if (arc.ilabel == 0) ++niepsilons_; + if (arc.olabel == 0) ++noepsilons_; + } + + // Adds one arc at a time with delayed book-keeping; finalize with SetArcs(). + void PushArc(const Arc &arc) { arcs_.push_back(arc); } + + // Finalizes arcs book-keeping; call only once. + void SetArcs() { + for (const auto &arc : arcs_) { + if (arc.ilabel == 0) ++niepsilons_; + if (arc.olabel == 0) ++noepsilons_; + } + } + + // Modifies nth arc. + void SetArc(const Arc &arc, size_t n) { + if (arcs_[n].ilabel == 0) --niepsilons_; + if (arcs_[n].olabel == 0) --noepsilons_; + if (arc.ilabel == 0) ++niepsilons_; + if (arc.olabel == 0) ++noepsilons_; + arcs_[n] = arc; + } + + // Deletes all arcs. + void DeleteArcs() { + niepsilons_ = 0; + noepsilons_ = 0; + arcs_.clear(); + } + + void DeleteArcs(size_t n) { + for (size_t i = 0; i < n; ++i) { + if (arcs_.back().ilabel == 0) --niepsilons_; + if (arcs_.back().olabel == 0) --noepsilons_; + arcs_.pop_back(); + } + } + + // Sets status flags; used by the caller. + void SetFlags(uint32 flags, uint32 mask) const { + flags_ &= ~mask; + flags_ |= flags; + } + + // Mutates reference counts; used by the caller. + + int IncrRefCount() const { return ++ref_count_; } + + int DecrRefCount() const { return --ref_count_; } + + // Used by the ArcIterator> efficient implementation. + int *MutableRefCount() const { return &ref_count_; } + + // Used for state class allocation. + void *operator new(size_t size, StateAllocator *alloc) { + return alloc->allocate(1); + } + + // For state destruction and memory freeing. + static void Destroy(CacheState *state, StateAllocator *alloc) { + if (state) { + state->~CacheState(); + alloc->deallocate(state, 1); + } + } + + private: + Weight final_; // Final weight. + size_t niepsilons_; // # of input epsilons. + size_t noepsilons_; // # of output epsilons. + std::vector arcs_; // Arcs representation. + mutable uint32 flags_; + mutable int ref_count_; // If 0, available for GC. +}; + +// Cache store, allocating and storing states, providing a mapping from state +// IDs to cached states, and an iterator over these states. The state template +// argument must implement the CacheState interface. The state for a StateId s +// is constructed when requested by GetMutableState(s) if it is not yet stored. +// Initially, a state has a reference count of zero, but the user may increment +// or decrement this to control the time of destruction. In particular, a state +// is destroyed when: +// +// 1. This instance is destroyed, or +// 2. Clear() or Delete() is called, or +// 3. Possibly (implementation-dependently) when: +// - Garbage collection is enabled (as defined by opts.gc), +// - The cache store size exceeds the limits (as defined by opts.gc_limits), +// - The state's reference count is zero, and +// - The state is not the most recently requested state. +// +// template +// class CacheStore { +// public: +// using State = S; +// using Arc = typename State::Arc; +// using StateId = typename Arc::StateId; +// +// // Required constructors/assignment operators. +// explicit CacheStore(const CacheOptions &opts); +// +// // Returns nullptr if state is not stored. +// const State *GetState(StateId s); +// +// // Creates state if state is not stored. +// State *GetMutableState(StateId s); +// +// // Similar to State::AddArc() but updates cache store book-keeping. +// void AddArc(State *state, const Arc &arc); +// +// // Similar to State::SetArcs() but updates cache store book-keeping; call +// // only once. +// void SetArcs(State *state); +// +// // Similar to State::DeleteArcs() but updates cache store book-keeping. +// +// void DeleteArcs(State *state); +// +// void DeleteArcs(State *state, size_t n); +// +// // Deletes all cached states. +// void Clear(); +// +// // Iterates over cached states (in an arbitrary order); only needed if +// // opts.gc is true. +// bool Done() const; // End of iteration. +// StateId Value() const; // Current state. +// void Next(); // Advances to next state (when !Done). +// void Reset(); // Returns to initial condition. +// void Delete(); // Deletes current state and advances to next. +// }; + +// Container cache stores. + +// This class uses a vector of pointers to states to store cached states. +template +class VectorCacheStore { + public: + using State = S; + using Arc = typename State::Arc; + using StateId = typename Arc::StateId; + using StateList = std::list>; + + // Required constructors/assignment operators. + explicit VectorCacheStore(const CacheOptions &opts) : cache_gc_(opts.gc) { + Clear(); + Reset(); + } + + VectorCacheStore(const VectorCacheStore &store) + : cache_gc_(store.cache_gc_) { + CopyStates(store); + Reset(); + } + + ~VectorCacheStore() { Clear(); } + + VectorCacheStore &operator=(const VectorCacheStore &store) { + if (this != &store) { + CopyStates(store); + Reset(); + } + return *this; + } + + // Returns nullptr if state is not stored. + const State *GetState(StateId s) const { + return s < state_vec_.size() ? state_vec_[s] : nullptr; + } + + // Creates state if state is not stored. + State *GetMutableState(StateId s) { + State *state = nullptr; + if (s >= state_vec_.size()) { + state_vec_.resize(s + 1, nullptr); + } else { + state = state_vec_[s]; + } + if (!state) { + state = new (&state_alloc_) State(arc_alloc_); + state_vec_[s] = state; + if (cache_gc_) state_list_.push_back(s); + } + return state; + } + + // Similar to State::AddArc() but updates cache store book-keeping + void AddArc(State *state, const Arc &arc) { state->AddArc(arc); } + + // Similar to State::SetArcs() but updates cache store book-keeping; call + // only once. + void SetArcs(State *state) { state->SetArcs(); } + + // Deletes all arcs. + void DeleteArcs(State *state) { state->DeleteArcs(); } + + // Deletes some arcs. + void DeleteArcs(State *state, size_t n) { state->DeleteArcs(n); } + + // Deletes all cached states. + void Clear() { + for (StateId s = 0; s < state_vec_.size(); ++s) { + State::Destroy(state_vec_[s], &state_alloc_); + } + state_vec_.clear(); + state_list_.clear(); + } + + // Iterates over cached states (in an arbitrary order); only works if GC is + // enabled (o.w. avoiding state_list_ overhead). + bool Done() const { return iter_ == state_list_.end(); } + + StateId Value() const { return *iter_; } + + void Next() { ++iter_; } + + void Reset() { iter_ = state_list_.begin(); } + + // Deletes current state and advances to next. + void Delete() { + State::Destroy(state_vec_[*iter_], &state_alloc_); + state_vec_[*iter_] = nullptr; + state_list_.erase(iter_++); + } + + private: + void CopyStates(const VectorCacheStore &store) { + Clear(); + state_vec_.reserve(store.state_vec_.size()); + for (StateId s = 0; s < store.state_vec_.size(); ++s) { + State *state = nullptr; + const auto *store_state = store.state_vec_[s]; + if (store_state) { + state = new (&state_alloc_) State(*store_state, arc_alloc_); + if (cache_gc_) state_list_.push_back(s); + } + state_vec_.push_back(state); + } + } + + bool cache_gc_; // Supports iteration when true. + std::vector state_vec_; // Vector of states (or null). + StateList state_list_; // List of states. + typename StateList::iterator iter_; // State list iterator. + typename State::StateAllocator state_alloc_; // For state allocation. + typename State::ArcAllocator arc_alloc_; // For arc allocation. +}; + +// This class uses a hash map from state IDs to pointers to cached states. +template +class HashCacheStore { + public: + using State = S; + using Arc = typename State::Arc; + using StateId = typename Arc::StateId; + + using StateMap = + std::unordered_map, + std::equal_to, + PoolAllocator>>; + + // Required constructors/assignment operators. + explicit HashCacheStore(const CacheOptions &opts) { + Clear(); + Reset(); + } + + HashCacheStore(const HashCacheStore &store) { + CopyStates(store); + Reset(); + } + + ~HashCacheStore() { Clear(); } + + HashCacheStore &operator=(const HashCacheStore &store) { + if (this != &store) { + CopyStates(store); + Reset(); + } + return *this; + } + + // Returns nullptr if state is not stored. + const State *GetState(StateId s) const { + const auto it = state_map_.find(s); + return it != state_map_.end() ? it->second : nullptr; + } + + // Creates state if state is not stored. + State *GetMutableState(StateId s) { + auto *&state = state_map_[s]; + if (!state) state = new (&state_alloc_) State(arc_alloc_); + return state; + } + + // Similar to State::AddArc() but updates cache store book-keeping. + void AddArc(State *state, const Arc &arc) { state->AddArc(arc); } + + // Similar to State::SetArcs() but updates internal cache size; call only + // once. + void SetArcs(State *state) { state->SetArcs(); } + + // Deletes all arcs. + void DeleteArcs(State *state) { state->DeleteArcs(); } + + // Deletes some arcs. + void DeleteArcs(State *state, size_t n) { state->DeleteArcs(n); } + + // Deletes all cached states. + void Clear() { + for (auto it = state_map_.begin(); it != state_map_.end(); ++it) { + State::Destroy(it->second, &state_alloc_); + } + state_map_.clear(); + } + + // Iterates over cached states (in an arbitrary order). + bool Done() const { return iter_ == state_map_.end(); } + + StateId Value() const { return iter_->first; } + + void Next() { ++iter_; } + + void Reset() { iter_ = state_map_.begin(); } + + // Deletes current state and advances to next. + void Delete() { + State::Destroy(iter_->second, &state_alloc_); + state_map_.erase(iter_++); + } + + private: + void CopyStates(const HashCacheStore &store) { + Clear(); + for (auto it = store.state_map_.begin(); it != store.state_map_.end(); + ++it) { + state_map_[it->first] = + new (&state_alloc_) State(*it->second, arc_alloc_); + } + } + + StateMap state_map_; // Map from state ID to state. + typename StateMap::iterator iter_; // State map iterator. + typename State::StateAllocator state_alloc_; // For state allocation. + typename State::ArcAllocator arc_alloc_; // For arc allocation. +}; + +// Garbage-colllection cache stores. + +// This class implements a simple garbage collection scheme when +// 'opts.gc_limit = 0'. In particular, the first cached state is reused for each +// new state so long as the reference count is zero on the to-be-reused state. +// Otherwise, the full underlying store is used. The caller can increment the +// reference count to inhibit the GC of in-use states (e.g., in an ArcIterator). +// +// The typical use case for this optimization is when a single pass over a +// cached +// FST is performed with only one-state expanded at a time. +template +class FirstCacheStore { + public: + using State = typename CacheStore::State; + using Arc = typename State::Arc; + using StateId = typename Arc::StateId; + + // Required constructors/assignment operators. + explicit FirstCacheStore(const CacheOptions &opts) + : store_(opts), + cache_gc_(opts.gc_limit == 0), // opts.gc ignored historically. + cache_first_state_id_(kNoStateId), + cache_first_state_(nullptr) {} + + FirstCacheStore(const FirstCacheStore &store) + : store_(store.store_), + cache_gc_(store.cache_gc_), + cache_first_state_id_(store.cache_first_state_id_), + cache_first_state_(store.cache_first_state_id_ != kNoStateId + ? store_.GetMutableState(0) + : nullptr) {} + + FirstCacheStore &operator=( + const FirstCacheStore &store) { + if (this != &store) { + store_ = store.store_; + cache_gc_ = store.cache_gc_; + cache_first_state_id_ = store.cache_first_state_id_; + cache_first_state_ = store.cache_first_state_id_ != kNoStateId + ? store_.GetMutableState(0) + : nullptr; + } + return *this; + } + + // Returns nullptr if state is not stored. + const State *GetState(StateId s) const { + // store_ state 0 may hold first cached state; the rest are shifted by 1. + return s == cache_first_state_id_ ? cache_first_state_ + : store_.GetState(s + 1); + } + + // Creates state if state is not stored. + State *GetMutableState(StateId s) { + // store_ state 0 used to hold first cached state; the rest are shifted by + // 1. + if (cache_first_state_id_ == s) { + return cache_first_state_; // Request for first cached state. + } + if (cache_gc_) { + if (cache_first_state_id_ == kNoStateId) { + cache_first_state_id_ = s; // Sets first cached state. + cache_first_state_ = store_.GetMutableState(0); + cache_first_state_->SetFlags(kCacheInit, kCacheInit); + cache_first_state_->ReserveArcs(2 * kAllocSize); + return cache_first_state_; + } else if (cache_first_state_->RefCount() == 0) { + cache_first_state_id_ = s; // Updates first cached state. + cache_first_state_->Reset(); + cache_first_state_->SetFlags(kCacheInit, kCacheInit); + return cache_first_state_; + } else { // Keeps first cached state. + cache_first_state_->SetFlags(0, kCacheInit); // Clears initialized bit. + cache_gc_ = false; // Disables GC. + } + } + auto *state = store_.GetMutableState(s + 1); + return state; + } + + // Similar to State::AddArc() but updates cache store book-keeping. + void AddArc(State *state, const Arc &arc) { store_.AddArc(state, arc); } + + // Similar to State::SetArcs() but updates internal cache size; call only + // once. + void SetArcs(State *state) { store_.SetArcs(state); } + + // Deletes all arcs + void DeleteArcs(State *state) { store_.DeleteArcs(state); } + + // Deletes some arcs + void DeleteArcs(State *state, size_t n) { store_.DeleteArcs(state, n); } + + // Deletes all cached states + void Clear() { + store_.Clear(); + cache_first_state_id_ = kNoStateId; + cache_first_state_ = nullptr; + } + + // Iterates over cached states (in an arbitrary order). Only needed if GC is + // enabled. + bool Done() const { return store_.Done(); } + + StateId Value() const { + // store_ state 0 may hold first cached state; rest shifted + 1. + const auto s = store_.Value(); + return s ? s - 1 : cache_first_state_id_; + } + + void Next() { store_.Next(); } + + void Reset() { store_.Reset(); } + + // Deletes current state and advances to next. + void Delete() { + if (Value() == cache_first_state_id_) { + cache_first_state_id_ = kNoStateId; + cache_first_state_ = nullptr; + } + store_.Delete(); + } + + private: + CacheStore store_; // Underlying store. + bool cache_gc_; // GC enabled. + StateId cache_first_state_id_; // First cached state ID. + State *cache_first_state_; // First cached state. +}; + +// This class implements mark-sweep garbage collection on an underlying cache +// store. If GC is enabled, garbage collection of states is performed in a +// rough approximation of LRU order once when 'gc_limit' bytes is reached. The +// caller can increment the reference count to inhibit the GC of in-use state +// (e.g., in an ArcIterator). With GC enabled, the 'gc_limit' parameter allows +// the caller to trade-off time vs. space. +template +class GCCacheStore { + public: + using State = typename CacheStore::State; + using Arc = typename State::Arc; + using StateId = typename Arc::StateId; + + // Required constructors/assignment operators. + explicit GCCacheStore(const CacheOptions &opts) + : store_(opts), + cache_gc_request_(opts.gc), + cache_limit_(opts.gc_limit > kMinCacheLimit ? opts.gc_limit + : kMinCacheLimit), + cache_gc_(false), + cache_size_(0) {} + + // Returns 0 if state is not stored. + const State *GetState(StateId s) const { return store_.GetState(s); } + + // Creates state if state is not stored + State *GetMutableState(StateId s) { + auto *state = store_.GetMutableState(s); + if (cache_gc_request_ && !(state->Flags() & kCacheInit)) { + state->SetFlags(kCacheInit, kCacheInit); + cache_size_ += sizeof(State) + state->NumArcs() * sizeof(Arc); + // GC is enabled once an uninited state (from underlying store) is seen. + cache_gc_ = true; + if (cache_size_ > cache_limit_) GC(state, false); + } + return state; + } + + // Similar to State::AddArc() but updates cache store book-keeping. + void AddArc(State *state, const Arc &arc) { + store_.AddArc(state, arc); + if (cache_gc_ && (state->Flags() & kCacheInit)) { + cache_size_ += sizeof(Arc); + if (cache_size_ > cache_limit_) GC(state, false); + } + } + + // Similar to State::SetArcs() but updates internal cache size; call only + // once. + void SetArcs(State *state) { + store_.SetArcs(state); + if (cache_gc_ && (state->Flags() & kCacheInit)) { + cache_size_ += state->NumArcs() * sizeof(Arc); + if (cache_size_ > cache_limit_) GC(state, false); + } + } + + // Deletes all arcs. + void DeleteArcs(State *state) { + if (cache_gc_ && (state->Flags() & kCacheInit)) { + cache_size_ -= state->NumArcs() * sizeof(Arc); + } + store_.DeleteArcs(state); + } + + // Deletes some arcs. + void DeleteArcs(State *state, size_t n) { + if (cache_gc_ && (state->Flags() & kCacheInit)) { + cache_size_ -= n * sizeof(Arc); + } + store_.DeleteArcs(state, n); + } + + // Deletes all cached states. + void Clear() { + store_.Clear(); + cache_size_ = 0; + } + + // Iterates over cached states (in an arbitrary order); only needed if GC is + // enabled. + bool Done() const { return store_.Done(); } + + StateId Value() const { return store_.Value(); } + + void Next() { store_.Next(); } + + void Reset() { store_.Reset(); } + + // Deletes current state and advances to next. + void Delete() { + if (cache_gc_) { + const auto *state = store_.GetState(Value()); + if (state->Flags() & kCacheInit) { + cache_size_ -= sizeof(State) + state->NumArcs() * sizeof(Arc); + } + } + store_.Delete(); + } + + // Removes from the cache store (not referenced-counted and not the current) + // states that have not been accessed since the last GC until at most + // cache_fraction * cache_limit_ bytes are cached. If that fails to free + // enough, attempts to uncaching recently visited states as well. If still + // unable to free enough memory, then widens cache_limit_. + void GC(const State *current, bool free_recent, float cache_fraction = 0.666); + + // Returns the current cache size in bytes or 0 if GC is disabled. + size_t CacheSize() const { return cache_size_; } + + // Returns the cache limit in bytes. + size_t CacheLimit() const { return cache_limit_; } + + private: + static constexpr size_t kMinCacheLimit = 8096; // Minimum cache limit. + + CacheStore store_; // Underlying store. + bool cache_gc_request_; // GC requested but possibly not yet enabled. + size_t cache_limit_; // Number of bytes allowed before GC. + bool cache_gc_; // GC enabled + size_t cache_size_; // Number of bytes cached. +}; + +template +void GCCacheStore::GC(const State *current, bool free_recent, + float cache_fraction) { + if (!cache_gc_) return; + VLOG(2) << "GCCacheStore: Enter GC: object = " + << "(" << this << "), free recently cached = " << free_recent + << ", cache size = " << cache_size_ + << ", cache frac = " << cache_fraction + << ", cache limit = " << cache_limit_ << "\n"; + size_t cache_target = cache_fraction * cache_limit_; + store_.Reset(); + while (!store_.Done()) { + auto *state = store_.GetMutableState(store_.Value()); + if (cache_size_ > cache_target && state->RefCount() == 0 && + (free_recent || !(state->Flags() & kCacheRecent)) && state != current) { + if (state->Flags() & kCacheInit) { + size_t size = sizeof(State) + state->NumArcs() * sizeof(Arc); + if (size < cache_size_) { + cache_size_ -= size; + } + } + store_.Delete(); + } else { + state->SetFlags(0, kCacheRecent); + store_.Next(); + } + } + if (!free_recent && cache_size_ > cache_target) { // Recurses on recent. + GC(current, true, cache_fraction); + } else if (cache_target > 0) { // Widens cache limit. + while (cache_size_ > cache_target) { + cache_limit_ *= 2; + cache_target *= 2; + } + } else if (cache_size_ > 0) { + FSTERROR() << "GCCacheStore:GC: Unable to free all cached states"; + } + VLOG(2) << "GCCacheStore: Exit GC: object = " + << "(" << this << "), free recently cached = " << free_recent + << ", cache size = " << cache_size_ + << ", cache frac = " << cache_fraction + << ", cache limit = " << cache_limit_ << "\n"; +} + +template +constexpr size_t GCCacheStore::kMinCacheLimit; + +// This class is the default cache state and store used by CacheBaseImpl. +// It uses VectorCacheStore for storage decorated by FirstCacheStore +// and GCCacheStore to do (optional) garbage collection. +template +class DefaultCacheStore + : public GCCacheStore>>> { + public: + explicit DefaultCacheStore(const CacheOptions &opts) + : GCCacheStore>>>(opts) { + } +}; + +namespace internal { + +// This class is used to cache FST elements stored in states of type State +// (see CacheState) with the flags used to indicate what has been cached. Use +// HasStart(), HasFinal(), and HasArcs() to determine if cached and SetStart(), +// SetFinal(), AddArc(), (or PushArc() and SetArcs()) to cache. Note that you +// must set the final weight even if the state is non-final to mark it as +// cached. The state storage method and any garbage collection policy are +// determined by the cache store. If the store is passed in with the options, +// CacheBaseImpl takes ownership. +template > +class CacheBaseImpl : public FstImpl { + public: + using Arc = typename State::Arc; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using Store = CacheStore; + + using FstImpl::Type; + using FstImpl::Properties; + + explicit CacheBaseImpl(const CacheOptions &opts = CacheOptions()) + : has_start_(false), + cache_start_(kNoStateId), + nknown_states_(0), + min_unexpanded_state_id_(0), + max_expanded_state_id_(-1), + cache_gc_(opts.gc), + cache_limit_(opts.gc_limit), + cache_store_(new CacheStore(opts)), + new_cache_store_(true), + own_cache_store_(true) {} + + explicit CacheBaseImpl(const CacheImplOptions &opts) + : has_start_(false), + cache_start_(kNoStateId), + nknown_states_(0), + min_unexpanded_state_id_(0), + max_expanded_state_id_(-1), + cache_gc_(opts.gc), + cache_limit_(opts.gc_limit), + cache_store_(opts.store ? opts.store : new CacheStore(CacheOptions( + opts.gc, opts.gc_limit))), + new_cache_store_(!opts.store), + own_cache_store_(opts.store ? opts.own_store : true) {} + + // Preserve gc parameters. If preserve_cache is true, also preserves + // cache data. + CacheBaseImpl(const CacheBaseImpl &impl, + bool preserve_cache = false) + : FstImpl(), + has_start_(false), + cache_start_(kNoStateId), + nknown_states_(0), + min_unexpanded_state_id_(0), + max_expanded_state_id_(-1), + cache_gc_(impl.cache_gc_), + cache_limit_(impl.cache_limit_), + cache_store_(new CacheStore(CacheOptions(cache_gc_, cache_limit_))), + new_cache_store_(impl.new_cache_store_ || !preserve_cache), + own_cache_store_(true) { + if (preserve_cache) { + *cache_store_ = *impl.cache_store_; + has_start_ = impl.has_start_; + cache_start_ = impl.cache_start_; + nknown_states_ = impl.nknown_states_; + expanded_states_ = impl.expanded_states_; + min_unexpanded_state_id_ = impl.min_unexpanded_state_id_; + max_expanded_state_id_ = impl.max_expanded_state_id_; + } + } + + ~CacheBaseImpl() override { if (own_cache_store_) delete cache_store_; } + + void SetStart(StateId s) { + cache_start_ = s; + has_start_ = true; + if (s >= nknown_states_) nknown_states_ = s + 1; + } + + void SetFinal(StateId s, Weight weight) { + auto *state = cache_store_->GetMutableState(s); + state->SetFinal(std::move(weight)); + static constexpr auto flags = kCacheFinal | kCacheRecent; + state->SetFlags(flags, flags); + } + +// Disabled to ensure PushArc not AddArc is used in existing code +// TODO(sorenj): re-enable for backing store +#if 0 + // AddArc adds a single arc to a state and does incremental cache + // book-keeping. For efficiency, prefer PushArc and SetArcs below + // when possible. + void AddArc(StateId s, const Arc &arc) { + auto *state = cache_store_->GetMutableState(s); + cache_store_->AddArc(state, arc); + if (arc.nextstate >= nknown_states_) + nknown_states_ = arc.nextstate + 1; + SetExpandedState(s); + static constexpr auto flags = kCacheArcs | kCacheRecent; + state->SetFlags(flags, flags); + } +#endif + + // Adds a single arc to a state but delays cache book-keeping. SetArcs must + // be called when all PushArc calls at a state are complete. Do not mix with + // calls to AddArc. + void PushArc(StateId s, const Arc &arc) { + auto *state = cache_store_->GetMutableState(s); + state->PushArc(arc); + } + + // Marks arcs of a state as cached and does cache book-keeping after all + // calls to PushArc have been completed. Do not mix with calls to AddArc. + void SetArcs(StateId s) { + auto *state = cache_store_->GetMutableState(s); + cache_store_->SetArcs(state); + const auto narcs = state->NumArcs(); + for (size_t a = 0; a < narcs; ++a) { + const auto &arc = state->GetArc(a); + if (arc.nextstate >= nknown_states_) nknown_states_ = arc.nextstate + 1; + } + SetExpandedState(s); + static constexpr auto flags = kCacheArcs | kCacheRecent; + state->SetFlags(flags, flags); + } + + void ReserveArcs(StateId s, size_t n) { + auto *state = cache_store_->GetMutableState(s); + state->ReserveArcs(n); + } + + void DeleteArcs(StateId s) { + auto *state = cache_store_->GetMutableState(s); + cache_store_->DeleteArcs(state); + } + + void DeleteArcs(StateId s, size_t n) { + auto *state = cache_store_->GetMutableState(s); + cache_store_->DeleteArcs(state, n); + } + + void Clear() { + nknown_states_ = 0; + min_unexpanded_state_id_ = 0; + max_expanded_state_id_ = -1; + has_start_ = false; + cache_start_ = kNoStateId; + cache_store_->Clear(); + } + + // Is the start state cached? + bool HasStart() const { + if (!has_start_ && Properties(kError)) has_start_ = true; + return has_start_; + } + + // Is the final weight of the state cached? + bool HasFinal(StateId s) const { + const auto *state = cache_store_->GetState(s); + if (state && state->Flags() & kCacheFinal) { + state->SetFlags(kCacheRecent, kCacheRecent); + return true; + } else { + return false; + } + } + + // Are arcs of the state cached? + bool HasArcs(StateId s) const { + const auto *state = cache_store_->GetState(s); + if (state && state->Flags() & kCacheArcs) { + state->SetFlags(kCacheRecent, kCacheRecent); + return true; + } else { + return false; + } + } + + StateId Start() const { return cache_start_; } + + Weight Final(StateId s) const { + const auto *state = cache_store_->GetState(s); + return state->Final(); + } + + size_t NumArcs(StateId s) const { + const auto *state = cache_store_->GetState(s); + return state->NumArcs(); + } + + size_t NumInputEpsilons(StateId s) const { + const auto *state = cache_store_->GetState(s); + return state->NumInputEpsilons(); + } + + size_t NumOutputEpsilons(StateId s) const { + const auto *state = cache_store_->GetState(s); + return state->NumOutputEpsilons(); + } + + // Provides information needed for generic arc iterator. + void InitArcIterator(StateId s, ArcIteratorData *data) const { + const auto *state = cache_store_->GetState(s); + data->base = nullptr; + data->narcs = state->NumArcs(); + data->arcs = state->Arcs(); + data->ref_count = state->MutableRefCount(); + state->IncrRefCount(); + } + + // Number of known states. + StateId NumKnownStates() const { return nknown_states_; } + + // Updates number of known states, taking into account the passed state ID. + void UpdateNumKnownStates(StateId s) { + if (s >= nknown_states_) nknown_states_ = s + 1; + } + + // Finds the mininum never-expanded state ID. + StateId MinUnexpandedState() const { + while (min_unexpanded_state_id_ <= max_expanded_state_id_ && + ExpandedState(min_unexpanded_state_id_)) { + ++min_unexpanded_state_id_; + } + return min_unexpanded_state_id_; + } + + // Returns maximum ever-expanded state ID. + StateId MaxExpandedState() const { return max_expanded_state_id_; } + + void SetExpandedState(StateId s) { + if (s > max_expanded_state_id_) max_expanded_state_id_ = s; + if (s < min_unexpanded_state_id_) return; + if (s == min_unexpanded_state_id_) ++min_unexpanded_state_id_; + if (cache_gc_ || cache_limit_ == 0) { + if (expanded_states_.size() <= s) expanded_states_.resize(s + 1, false); + expanded_states_[s] = true; + } + } + + bool ExpandedState(StateId s) const { + if (cache_gc_ || cache_limit_ == 0) { + return expanded_states_[s]; + } else if (new_cache_store_) { + return cache_store_->GetState(s) != nullptr; + } else { + // If the cache was not created by this class, then the cached state needs + // to be inspected to update nknown_states_. + return false; + } + } + + const CacheStore *GetCacheStore() const { return cache_store_; } + + CacheStore *GetCacheStore() { return cache_store_; } + + // Caching on/off switch, limit and size accessors. + + bool GetCacheGc() const { return cache_gc_; } + + size_t GetCacheLimit() const { return cache_limit_; } + + private: + mutable bool has_start_; // Is the start state cached? + StateId cache_start_; // ID of start state. + StateId nknown_states_; // Number of known states. + std::vector expanded_states_; // States that have been expanded. + mutable StateId min_unexpanded_state_id_; // Minimum never-expanded state ID + mutable StateId max_expanded_state_id_; // Maximum ever-expanded state ID + bool cache_gc_; // GC enabled. + size_t cache_limit_; // Number of bytes allowed before GC. + CacheStore *cache_store_; // The store of cached states. + bool new_cache_store_; // Was the store was created by class? + bool own_cache_store_; // Is the store owned by class? + + CacheBaseImpl &operator=(const CacheBaseImpl &impl) = delete; +}; + +// A CacheBaseImpl with the default cache state type. +template +class CacheImpl : public CacheBaseImpl> { + public: + using State = CacheState; + + CacheImpl() {} + + explicit CacheImpl(const CacheOptions &opts) + : CacheBaseImpl>(opts) {} + + CacheImpl(const CacheImpl &impl, bool preserve_cache = false) + : CacheBaseImpl(impl, preserve_cache) {} + + private: + CacheImpl &operator=(const CacheImpl &impl) = delete; +}; + +} // namespace internal + +// Use this to make a state iterator for a CacheBaseImpl-derived FST, which must +// have Arc and Store types defined. Note this iterator only returns those +// states reachable from the initial state, so consider implementing a +// class-specific one. +// +// This class may be derived from. +template +class CacheStateIterator : public StateIteratorBase { + public: + using Arc = typename FST::Arc; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using Store = typename FST::Store; + using State = typename Store::State; + using Impl = internal::CacheBaseImpl; + + CacheStateIterator(const FST &fst, Impl *impl) + : fst_(fst), impl_(impl), s_(0) { + fst_.Start(); // Forces start state. + } + + bool Done() const final { + if (s_ < impl_->NumKnownStates()) return false; + for (StateId u = impl_->MinUnexpandedState(); u < impl_->NumKnownStates(); + u = impl_->MinUnexpandedState()) { + // Forces state expansion. + ArcIterator aiter(fst_, u); + aiter.SetFlags(kArcValueFlags, kArcValueFlags | kArcNoCache); + for (; !aiter.Done(); aiter.Next()) { + impl_->UpdateNumKnownStates(aiter.Value().nextstate); + } + impl_->SetExpandedState(u); + if (s_ < impl_->NumKnownStates()) return false; + } + return true; + } + + StateId Value() const final { return s_; } + + void Next() final { ++s_; } + + void Reset() final { s_ = 0; } + + private: + const FST &fst_; + Impl *impl_; + StateId s_; +}; + +// Used to make an arc iterator for a CacheBaseImpl-derived FST, which must +// have Arc and State types defined. +template +class CacheArcIterator { + public: + using Arc = typename FST::Arc; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using Store = typename FST::Store; + using State = typename Store::State; + using Impl = internal::CacheBaseImpl; + + CacheArcIterator(Impl *impl, StateId s) : i_(0) { + state_ = impl->GetCacheStore()->GetMutableState(s); + state_->IncrRefCount(); + } + + ~CacheArcIterator() { state_->DecrRefCount(); } + + bool Done() const { return i_ >= state_->NumArcs(); } + + const Arc &Value() const { return state_->GetArc(i_); } + + void Next() { ++i_; } + + size_t Position() const { return i_; } + + void Reset() { i_ = 0; } + + void Seek(size_t a) { i_ = a; } + + constexpr uint32 Flags() const { return kArcValueFlags; } + + void SetFlags(uint32 flags, uint32 mask) {} + + private: + const State *state_; + size_t i_; + + CacheArcIterator(const CacheArcIterator &) = delete; + CacheArcIterator &operator=(const CacheArcIterator &) = delete; +}; + +// Use this to make a mutable arc iterator for a CacheBaseImpl-derived FST, +// which must have types Arc and Store defined. +template +class CacheMutableArcIterator + : public MutableArcIteratorBase { + public: + using Arc = typename FST::Arc; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using Store = typename FST::Store; + using State = typename Store::State; + using Impl = internal::CacheBaseImpl; + + // User must call MutateCheck() in the constructor. + CacheMutableArcIterator(Impl *impl, StateId s) : i_(0), s_(s), impl_(impl) { + state_ = impl_->GetCacheStore()->GetMutableState(s_); + state_->IncrRefCount(); + } + + ~CacheMutableArcIterator() override { state_->DecrRefCount(); } + + bool Done() const final { return i_ >= state_->NumArcs(); } + + const Arc &Value() const final { return state_->GetArc(i_); } + + void Next() final { ++i_; } + + size_t Position() const final { return i_; } + + void Reset() final { i_ = 0; } + + void Seek(size_t a) final { i_ = a; } + + void SetValue(const Arc &arc) final { state_->SetArc(arc, i_); } + + uint32 Flags() const final { return kArcValueFlags; } + + void SetFlags(uint32, uint32) final {} + + private: + size_t i_; + StateId s_; + Impl *impl_; + State *state_; + + CacheMutableArcIterator(const CacheMutableArcIterator &) = delete; + CacheMutableArcIterator &operator=(const CacheMutableArcIterator &) = delete; +}; + +// Wrap existing CacheStore implementation to use with ExpanderFst. +template +class ExpanderCacheStore { + public: + using State = typename CacheStore::State; + using Arc = typename CacheStore::Arc; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + explicit ExpanderCacheStore(const CacheOptions &opts = CacheOptions()) + : store_(opts) {} + + template + State *FindOrExpand(Expander &expander, StateId s) { // NOLINT + auto *state = store_.GetMutableState(s); + if (state->Flags()) { + state->SetFlags(kCacheRecent, kCacheRecent); + } else { + StateBuilder builder(state); + expander.Expand(s, &builder); + state->SetFlags(kCacheFlags, kCacheFlags); + store_.SetArcs(state); + } + return state; + } + + private: + CacheStore store_; + + struct StateBuilder { + State *state; + + explicit StateBuilder(State *state_) : state(state_) {} + + void AddArc(const Arc &arc) { state->PushArc(arc); } + + void SetFinal(Weight weight) { state->SetFinal(std::move(weight)); } + }; +}; + +} // namespace fst + +#endif // FST_CACHE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/closure.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/closure.h new file mode 100644 index 0000000000..0e3df04c80 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/closure.h @@ -0,0 +1,136 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Functions and classes to compute the concatenative closure of an FST. + +#ifndef FST_CLOSURE_H_ +#define FST_CLOSURE_H_ + +#include +#include + +#include +#include + + +namespace fst { + +// Computes the concatenative closure. This version modifies its +// MutableFst input. If an FST transduces string x to y with weight a, +// then its closure transduces x to y with weight a, xx to yy with +// weight Times(a, a), xxx to yyy with with Times(Times(a, a), a), +// etc. If closure_type == CLOSURE_STAR, then the empty string is +// transduced to itself with weight Weight::One() as well. +// +// Complexity: +// +// Time: O(V) +// Space: O(V) +// +// where V is the number of states. +template +void Closure(MutableFst *fst, ClosureType closure_type) { + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + const auto props = fst->Properties(kFstProperties, false); + const auto start = fst->Start(); + for (StateIterator> siter(*fst); !siter.Done(); + siter.Next()) { + const auto s = siter.Value(); + const auto weight = fst->Final(s); + if (weight != Weight::Zero()) fst->AddArc(s, Arc(0, 0, weight, start)); + } + if (closure_type == CLOSURE_STAR) { + fst->ReserveStates(fst->NumStates() + 1); + const auto nstart = fst->AddState(); + fst->SetStart(nstart); + fst->SetFinal(nstart, Weight::One()); + if (start != kNoLabel) fst->AddArc(nstart, Arc(0, 0, Weight::One(), start)); + } + fst->SetProperties(ClosureProperties(props, closure_type == CLOSURE_STAR), + kFstProperties); +} + +// Computes the concatenative closure. This version modifies its +// RationalFst input. +template +void Closure(RationalFst *fst, ClosureType closure_type) { + fst->GetMutableImpl()->AddClosure(closure_type); +} + +struct ClosureFstOptions : RationalFstOptions { + ClosureType type; + + ClosureFstOptions(const RationalFstOptions &opts, + ClosureType type = CLOSURE_STAR) + : RationalFstOptions(opts), type(type) {} + + explicit ClosureFstOptions(ClosureType type = CLOSURE_STAR) : type(type) {} +}; + +// Computes the concatenative closure. This version is a delayed FST. If an FST +// transduces string x to y with weight a, then its closure transduces x to y +// with weight a, xx to yy with weight Times(a, a), xxx to yyy with weight +// Times(Times(a, a), a), etc. If closure_type == CLOSURE_STAR, then the empty +// string is transduced to itself with weight Weight::One() as well. +// +// Complexity: +// +// Time: O(v) +// Space: O(v) +// +// where v is the number of states visited. Constant time and space to visit an +// input state or arc is assumed and exclusive of caching. +template +class ClosureFst : public RationalFst { + public: + using Arc = A; + + ClosureFst(const Fst &fst, ClosureType closure_type) { + GetMutableImpl()->InitClosure(fst, closure_type); + } + + ClosureFst(const Fst &fst, const ClosureFstOptions &opts) + : RationalFst(opts) { + GetMutableImpl()->InitClosure(fst, opts.type); + } + + // See Fst<>::Copy() for doc. + ClosureFst(const ClosureFst &fst, bool safe = false) + : RationalFst(fst, safe) {} + + // Gets a copy of this ClosureFst. See Fst<>::Copy() for further doc. + ClosureFst *Copy(bool safe = false) const override { + return new ClosureFst(*this, safe); + } + + private: + using ImplToFst>::GetImpl; + using ImplToFst>::GetMutableImpl; +}; + +// Specialization for ClosureFst. +template +class StateIterator> : public StateIterator> { + public: + explicit StateIterator(const ClosureFst &fst) + : StateIterator>(fst) {} +}; + +// Specialization for ClosureFst. +template +class ArcIterator> : public ArcIterator> { + public: + using StateId = typename Arc::StateId; + + ArcIterator(const ClosureFst &fst, StateId s) + : ArcIterator>(fst, s) {} +}; + +// Useful alias when using StdArc. +using StdClosureFst = ClosureFst; + +} // namespace fst + +#endif // FST_CLOSURE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/compact-fst.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/compact-fst.h new file mode 100644 index 0000000000..df91895b18 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/compact-fst.h @@ -0,0 +1,1566 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// FST Class for memory-efficient representation of common types of +// FSTs: linear automata, acceptors, unweighted FSTs, ... + +#ifndef FST_COMPACT_FST_H_ +#define FST_COMPACT_FST_H_ + +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include // For optional argument declarations +#include +#include +#include +#include + + +namespace fst { + +struct CompactFstOptions : public CacheOptions { + // The default caching behaviour is to do no caching. Most compactors are + // cheap and therefore we save memory by not doing caching. + CompactFstOptions() : CacheOptions(true, 0) {} + + explicit CompactFstOptions(const CacheOptions &opts) : CacheOptions(opts) {} +}; + +// New upcoming (Fst) Compactor interface - currently used internally +// by CompactFstImpl. +// +// class Compactor { +// public: +// // Constructor from the Fst to be compacted. +// Compactor(const Fst &fst, ...); +// // Copy constructor +// Compactor(const Compactor &compactor, bool safe = false) +// // Default constructor (optional, see comment below). +// Compactor(); +// +// // Returns the start state, number of states, and total number of arcs +// // of the compacted Fst +// StateId Start() const; +// StateId NumStates() const; +// size_t NumArcs() const; +// +// // Accessor class for state attributes. +// class State { +// public: +// State(); // Required, corresponds to kNoStateId. +// State(const Compactor *c, StateId); // Accessor for StateId 's'. +// StateId GetStateId() const; +// Weight Final() const; +// size_t NumArcs() const; +// Arc GetArc(size_t i) const; +// }; +// +// // Modifies 'state' accessor to provide access to state id 's'. +// void SetState(StateId s, State *state); +// // Tests whether 'fst' can be compacted by this compactor. +// bool IsCompatible(const Fst &fst) const; +// // Return the properties that are always true for an fst +// // compacted using this compactor +// uint64 Properties() const; +// // Return a string identifying the type of compactor. +// static const string &Type(); +// // Return true if an error has occured. +// bool Error() const; +// // Writes a compactor to a file. +// bool Write(std::ostream &strm, const FstWriteOptions &opts) const; +// // Reads a compactor from a file. +// static Compactor*Read(std::istream &strm, const FstReadOptions &opts, +// const FstHeader &hdr); +// }; +// + +// Old (Arc) Compactor Interface: +// +// The ArcCompactor class determines how arcs and final weights are compacted +// and expanded. +// +// Final weights are treated as transitions to the superfinal state, i.e., +// ilabel = olabel = kNoLabel and nextstate = kNoStateId. +// +// There are two types of compactors: +// +// * Fixed out-degree compactors: 'compactor.Size()' returns a positive integer +// 's'. An FST can be compacted by this compactor only if each state has +// exactly 's' outgoing transitions (counting a non-Zero() final weight as a +// transition). A typical example is a compactor for string FSTs, i.e., +// 's == 1'. +// +// * Variable out-degree compactors: 'compactor.Size() == -1'. There are no +// out-degree restrictions for these compactors. +// +// Interface: +// +// class ArcCompactor { +// public: +// // Element is the type of the compacted transitions. +// using Element = ... +// +// // Returns the compacted representation of a transition 'arc' +// // at a state 's'. +// Element Compact(StateId s, const Arc &arc); +// +// // Returns the transition at state 's' represented by the compacted +// // transition 'e'. +// Arc Expand(StateId s, const Element &e) const; +// +// // Returns -1 for variable out-degree compactors, and the mandatory +// // out-degree otherwise. +// ssize_t Size() const; +// +// // Tests whether an FST can be compacted by this compactor. +// bool Compatible(const Fst &fst) const; +// +// // Returns the properties that are always true for an FST compacted using +// // this compactor +// uint64 Properties() const; +// +// // Returns a string identifying the type of compactor. +// static const string &Type(); +// +// // Writes a compactor to a file. +// bool Write(std::ostream &strm) const; +// +// // Reads a compactor from a file. +// static ArcCompactor *Read(std::istream &strm); +// +// // Default constructor (optional, see comment below). +// ArcCompactor(); +// }; +// +// The default constructor is only required for FST_REGISTER to work (i.e., +// enabling Convert() and the command-line utilities to work with this new +// compactor). However, a default constructor always needs to be specified for +// this code to compile, but one can have it simply raise an error when called, +// like so: +// +// Compactor::Compactor() { +// FSTERROR() << "Compactor: No default constructor"; +// } + +// Default implementation data for CompactFst, which can shared between +// otherwise independent copies. +// +// The implementation contains two arrays: 'states_' and 'compacts_'. +// +// For fixed out-degree compactors, the 'states_' array is unallocated. The +// 'compacts_' contains the compacted transitions. Its size is 'ncompacts_'. +// The outgoing transitions at a given state are stored consecutively. For a +// given state 's', its 'compactor.Size()' outgoing transitions (including +// superfinal transition when 's' is final), are stored in position +// ['s*compactor.Size()', '(s+1)*compactor.Size()'). +// +// For variable out-degree compactors, the states_ array has size +// 'nstates_ + 1' and contains pointers to positions into 'compacts_'. For a +// given state 's', the compacted transitions of 's' are stored in positions +// ['states_[s]', 'states_[s + 1]') in 'compacts_'. By convention, +// 'states_[nstates_] == ncompacts_'. +// +// In both cases, the superfinal transitions (when 's' is final, i.e., +// 'Final(s) != Weight::Zero()') are stored first. +// +// The unsigned type U is used to represent indices into the compacts_ array. +template +class DefaultCompactStore { + public: + DefaultCompactStore() + : states_(nullptr), + compacts_(nullptr), + nstates_(0), + ncompacts_(0), + narcs_(0), + start_(kNoStateId), + error_(false) {} + + template + DefaultCompactStore(const Fst &fst, const Compactor &compactor); + + template + DefaultCompactStore(const Iterator &begin, const Iterator &end, + const Compactor &compactor); + + ~DefaultCompactStore() { + if (!states_region_) delete[] states_; + if (!compacts_region_) delete[] compacts_; + } + + template + static DefaultCompactStore *Read( + std::istream &strm, const FstReadOptions &opts, const FstHeader &hdr, + const Compactor &compactor); + + bool Write(std::ostream &strm, const FstWriteOptions &opts) const; + + Unsigned States(ssize_t i) const { return states_[i]; } + + const Element &Compacts(size_t i) const { return compacts_[i]; } + + size_t NumStates() const { return nstates_; } + + size_t NumCompacts() const { return ncompacts_; } + + size_t NumArcs() const { return narcs_; } + + ssize_t Start() const { return start_; } + + bool Error() const { return error_; } + + // Returns a string identifying the type of data storage container. + static const string &Type(); + + private: + std::unique_ptr states_region_; + std::unique_ptr compacts_region_; + Unsigned *states_; + Element *compacts_; + size_t nstates_; + size_t ncompacts_; + size_t narcs_; + ssize_t start_; + bool error_; +}; + +template +template +DefaultCompactStore::DefaultCompactStore( + const Fst &fst, const Compactor &compactor) + : states_(nullptr), + compacts_(nullptr), + nstates_(0), + ncompacts_(0), + narcs_(0), + start_(kNoStateId), + error_(false) { + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + start_ = fst.Start(); + // Counts # of states and arcs. + StateId nfinals = 0; + for (StateIterator> siter(fst); !siter.Done(); siter.Next()) { + ++nstates_; + const auto s = siter.Value(); + for (ArcIterator> aiter(fst, s); !aiter.Done(); aiter.Next()) { + ++narcs_; + } + if (fst.Final(s) != Weight::Zero()) ++nfinals; + } + if (compactor.Size() == -1) { + states_ = new Unsigned[nstates_ + 1]; + ncompacts_ = narcs_ + nfinals; + compacts_ = new Element[ncompacts_]; + states_[nstates_] = ncompacts_; + } else { + states_ = nullptr; + ncompacts_ = nstates_ * compactor.Size(); + if ((narcs_ + nfinals) != ncompacts_) { + FSTERROR() << "DefaultCompactStore: Compactor incompatible with FST"; + error_ = true; + return; + } + compacts_ = new Element[ncompacts_]; + } + size_t pos = 0; + size_t fpos = 0; + for (size_t s = 0; s < nstates_; ++s) { + fpos = pos; + if (compactor.Size() == -1) states_[s] = pos; + if (fst.Final(s) != Weight::Zero()) { + compacts_[pos++] = compactor.Compact( + s, Arc(kNoLabel, kNoLabel, fst.Final(s), kNoStateId)); + } + for (ArcIterator> aiter(fst, s); !aiter.Done(); aiter.Next()) { + compacts_[pos++] = compactor.Compact(s, aiter.Value()); + } + if ((compactor.Size() != -1) && ((pos - fpos) != compactor.Size())) { + FSTERROR() << "DefaultCompactStore: Compactor incompatible with FST"; + error_ = true; + return; + } + } + if (pos != ncompacts_) { + FSTERROR() << "DefaultCompactStore: Compactor incompatible with FST"; + error_ = true; + return; + } +} + +template +template +DefaultCompactStore::DefaultCompactStore( + const Iterator &begin, const Iterator &end, const Compactor &compactor) + : states_(nullptr), + compacts_(nullptr), + nstates_(0), + ncompacts_(0), + narcs_(0), + start_(kNoStateId), + error_(false) { + using Arc = typename Compactor::Arc; + using Weight = typename Arc::Weight; + if (compactor.Size() != -1) { + ncompacts_ = std::distance(begin, end); + if (compactor.Size() == 1) { + // For strings, allows implicit final weight. Empty input is the empty + // string. + if (ncompacts_ == 0) { + ++ncompacts_; + } else { + const auto arc = + compactor.Expand(ncompacts_ - 1, *(begin + (ncompacts_ - 1))); + if (arc.ilabel != kNoLabel) ++ncompacts_; + } + } + if (ncompacts_ % compactor.Size()) { + FSTERROR() << "DefaultCompactStore: Size of input container incompatible" + << " with compactor"; + error_ = true; + return; + } + if (ncompacts_ == 0) return; + start_ = 0; + nstates_ = ncompacts_ / compactor.Size(); + compacts_ = new Element[ncompacts_]; + size_t i = 0; + Iterator it = begin; + for (; it != end; ++it, ++i) { + compacts_[i] = *it; + if (compactor.Expand(i, *it).ilabel != kNoLabel) ++narcs_; + } + if (i < ncompacts_) { + compacts_[i] = compactor.Compact( + i, Arc(kNoLabel, kNoLabel, Weight::One(), kNoStateId)); + } + } else { + if (std::distance(begin, end) == 0) return; + // Count # of states, arcs and compacts. + auto it = begin; + for (size_t i = 0; it != end; ++it, ++i) { + const auto arc = compactor.Expand(i, *it); + if (arc.ilabel != kNoLabel) { + ++narcs_; + ++ncompacts_; + } else { + ++nstates_; + if (arc.weight != Weight::Zero()) ++ncompacts_; + } + } + start_ = 0; + compacts_ = new Element[ncompacts_]; + states_ = new Unsigned[nstates_ + 1]; + states_[nstates_] = ncompacts_; + size_t i = 0; + size_t s = 0; + for (it = begin; it != end; ++it) { + const auto arc = compactor.Expand(i, *it); + if (arc.ilabel != kNoLabel) { + compacts_[i++] = *it; + } else { + states_[s++] = i; + if (arc.weight != Weight::Zero()) compacts_[i++] = *it; + } + } + if ((s != nstates_) || (i != ncompacts_)) { + FSTERROR() << "DefaultCompactStore: Ill-formed input container"; + error_ = true; + return; + } + } +} + +template +template +DefaultCompactStore + *DefaultCompactStore::Read(std::istream &strm, + const FstReadOptions &opts, + const FstHeader &hdr, + const Compactor &compactor) { + std::unique_ptr> data( + new DefaultCompactStore()); + data->start_ = hdr.Start(); + data->nstates_ = hdr.NumStates(); + data->narcs_ = hdr.NumArcs(); + if (compactor.Size() == -1) { + if ((hdr.GetFlags() & FstHeader::IS_ALIGNED) && !AlignInput(strm)) { + LOG(ERROR) << "DefaultCompactStore::Read: Alignment failed: " + << opts.source; + return nullptr; + } + auto b = (data->nstates_ + 1) * sizeof(Unsigned); + data->states_region_.reset(MappedFile::Map( + &strm, opts.mode == FstReadOptions::MAP, opts.source, b)); + if (!strm || !data->states_region_) { + LOG(ERROR) << "DefaultCompactStore::Read: Read failed: " << opts.source; + return nullptr; + } + data->states_ = + static_cast(data->states_region_->mutable_data()); + } else { + data->states_ = nullptr; + } + data->ncompacts_ = compactor.Size() == -1 ? data->states_[data->nstates_] + : data->nstates_ * compactor.Size(); + if ((hdr.GetFlags() & FstHeader::IS_ALIGNED) && !AlignInput(strm)) { + LOG(ERROR) << "DefaultCompactStore::Read: Alignment failed: " + << opts.source; + return nullptr; + } + size_t b = data->ncompacts_ * sizeof(Element); + data->compacts_region_.reset( + MappedFile::Map(&strm, opts.mode == FstReadOptions::MAP, opts.source, b)); + if (!strm || !data->compacts_region_) { + LOG(ERROR) << "DefaultCompactStore::Read: Read failed: " << opts.source; + return nullptr; + } + data->compacts_ = + static_cast(data->compacts_region_->mutable_data()); + return data.release(); +} + +template +bool DefaultCompactStore::Write( + std::ostream &strm, const FstWriteOptions &opts) const { + if (states_) { + if (opts.align && !AlignOutput(strm)) { + LOG(ERROR) << "DefaultCompactStore::Write: Alignment failed: " + << opts.source; + return false; + } + strm.write(reinterpret_cast(states_), + (nstates_ + 1) * sizeof(Unsigned)); + } + if (opts.align && !AlignOutput(strm)) { + LOG(ERROR) << "DefaultCompactStore::Write: Alignment failed: " + << opts.source; + return false; + } + strm.write(reinterpret_cast(compacts_), ncompacts_ * sizeof(Element)); + strm.flush(); + if (!strm) { + LOG(ERROR) << "DefaultCompactStore::Write: Write failed: " << opts.source; + return false; + } + return true; +} + +template +const string &DefaultCompactStore::Type() { + static const string *const type = new string("compact"); + return *type; +} + +template class DefaultCompactState; + +// Wraps an arc compactor and a compact store as a new Fst compactor. +template > +class DefaultCompactor { + public: + using ArcCompactor = C; + using Unsigned = U; + using CompactStore = S; + using Element = typename C::Element; + using Arc = typename C::Arc; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + using State = DefaultCompactState; + friend State; + + DefaultCompactor() + : arc_compactor_(nullptr), compact_store_(nullptr) {} + + // Constructs from Fst. + DefaultCompactor(const Fst &fst, + std::shared_ptr arc_compactor) + : arc_compactor_(std::move(arc_compactor)), + compact_store_(std::make_shared(fst, *arc_compactor_)) {} + + DefaultCompactor(const Fst &fst, + std::shared_ptr> compactor) + : arc_compactor_(compactor->arc_compactor_), + compact_store_(compactor->compact_store_ == nullptr ? + std::make_shared(fst, *arc_compactor_) : + compactor->compact_store_) {} + + // Constructs from CompactStore. + DefaultCompactor(std::shared_ptr arc_compactor, + std::shared_ptr compact_store) + : arc_compactor_(std::move(arc_compactor)), + compact_store_(std::move(compact_store)) {} + + // Constructs from set of compact elements (when arc_compactor.Size() != -1). + template + DefaultCompactor(const Iterator &b, const Iterator &e, + std::shared_ptr arc_compactor) + : arc_compactor_(std::move(arc_compactor)), + compact_store_(std::make_shared(b, e, *arc_compactor_)) {} + + // Copy constructor. + DefaultCompactor(const DefaultCompactor &compactor) + : arc_compactor_(std::make_shared(*compactor.GetArcCompactor())), + compact_store_(compactor.SharedCompactStore()) {} + + template + explicit DefaultCompactor(const DefaultCompactor &compactor) + : arc_compactor_(std::make_shared(*compactor.GetArcCompactor())), + compact_store_(compactor.SharedCompactStore()) {} + + StateId Start() const { return compact_store_->Start(); } + StateId NumStates() const { return compact_store_->NumStates(); } + size_t NumArcs() const { return compact_store_->NumArcs(); } + + void SetState(StateId s, State *state) const { + if (state->GetStateId() != s) state->Set(this, s); + } + + static DefaultCompactor *Read(std::istream &strm, + const FstReadOptions &opts, + const FstHeader &hdr) { + std::shared_ptr arc_compactor(C::Read(strm)); + if (arc_compactor == nullptr) return nullptr; + std::shared_ptr compact_store(S::Read(strm, opts, hdr, *arc_compactor)); + if (compact_store == nullptr) return nullptr; + return new DefaultCompactor(arc_compactor, compact_store); + } + + bool Write(std::ostream &strm, const FstWriteOptions &opts) const { + return arc_compactor_->Write(strm) && compact_store_->Write(strm, opts); + } + + uint64 Properties() const { return arc_compactor_->Properties(); } + + bool IsCompatible(const Fst &fst) const { + return arc_compactor_->Compatible(fst); + } + + bool Error() const { return compact_store_->Error(); } + + bool HasFixedOutdegree() const { return arc_compactor_->Size() != -1; } + + static const string &Type() { + static const string *const type = [] { + string type = "compact"; + if (sizeof(U) != sizeof(uint32)) type += std::to_string(8 * sizeof(U)); + type += "_"; + type += C::Type(); + if (CompactStore::Type() != "compact") { + type += "_"; + type += CompactStore::Type(); + } + return new string(type); + }(); + return *type; + } + + const ArcCompactor *GetArcCompactor() const { return arc_compactor_.get(); } + CompactStore *GetCompactStore() const { return compact_store_.get(); } + + std::shared_ptr SharedArcCompactor() const { + return arc_compactor_; + } + + std::shared_ptr SharedCompactStore() const { + return compact_store_; + } + + // TODO(allauzen): remove dependencies on this method and make private. + Arc ComputeArc(StateId s, Unsigned i, uint32 f) const { + return arc_compactor_->Expand(s, compact_store_->Compacts(i), f); + } + + private: + std::pair CompactsRange(StateId s) const { + std::pair range; + if (HasFixedOutdegree()) { + range.first = s * arc_compactor_->Size(); + range.second = arc_compactor_->Size(); + } else { + range.first = compact_store_->States(s); + range.second = compact_store_->States(s + 1) - range.first; + } + return range; + } + + private: + std::shared_ptr arc_compactor_; + std::shared_ptr compact_store_; +}; + +// Default implementation of state attributes accessor class for +// DefaultCompactor. Use of efficient specialization strongly encouraged. +template +class DefaultCompactState { + public: + using Arc = typename C::Arc; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + DefaultCompactState() = default; + + DefaultCompactState(const DefaultCompactor *compactor, StateId s) + : compactor_(compactor), + s_(s), + range_(compactor->CompactsRange(s)), + has_final_( + range_.second != 0 && + compactor->ComputeArc(s, range_.first, + kArcILabelValue).ilabel == kNoLabel) { + if (has_final_) { + ++range_.first; + --range_.second; + } + } + + void Set(const DefaultCompactor *compactor, StateId s) { + compactor_ = compactor; + s_ = s; + range_ = compactor->CompactsRange(s); + if (range_.second != 0 && + compactor->ComputeArc(s, range_.first, kArcILabelValue).ilabel + == kNoLabel) { + has_final_ = true; + ++range_.first; + --range_.second; + } else { + has_final_ = false; + } + } + + StateId GetStateId() const { return s_; } + + Weight Final() const { + if (!has_final_) return Weight::Zero(); + return compactor_->ComputeArc(s_, range_.first - 1, kArcWeightValue).weight; + } + + size_t NumArcs() const { return range_.second; } + + Arc GetArc(size_t i, uint32 f) const { + return compactor_->ComputeArc(s_, range_.first + i, f); + } + + private: + const DefaultCompactor *compactor_ = nullptr; // borrowed ref. + StateId s_ = kNoStateId; + std::pair range_ = {0, 0}; + bool has_final_ = false; +}; + +// Specialization for DefaultCompactStore. +template +class DefaultCompactState> { + public: + using Arc = typename C::Arc; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + using CompactStore = DefaultCompactStore; + + DefaultCompactState() = default; + + DefaultCompactState( + const DefaultCompactor *compactor, StateId s) + : arc_compactor_(compactor->GetArcCompactor()), s_(s) { + Init(compactor); + } + + void Set(const DefaultCompactor *compactor, StateId s) { + arc_compactor_ = compactor->GetArcCompactor(); + s_ = s; + has_final_ = false; + Init(compactor); + } + + StateId GetStateId() const { return s_; } + + Weight Final() const { + if (!has_final_) return Weight::Zero(); + return arc_compactor_->Expand(s_, *(compacts_ - 1), kArcWeightValue).weight; + } + + size_t NumArcs() const { return num_arcs_; } + + Arc GetArc(size_t i, uint32 f) const { + return arc_compactor_->Expand(s_, compacts_[i], f); + } + + private: + void Init(const DefaultCompactor *compactor) { + const auto *store = compactor->GetCompactStore(); + U offset; + if (!compactor->HasFixedOutdegree()) { // Variable out-degree compactor. + offset = store->States(s_); + num_arcs_ = store->States(s_ + 1) - offset; + } else { // Fixed out-degree compactor. + offset = s_ * arc_compactor_->Size(); + num_arcs_ = arc_compactor_->Size(); + } + if (num_arcs_ > 0) { + compacts_ = &(store->Compacts(offset)); + if (arc_compactor_->Expand(s_, *compacts_, kArcILabelValue).ilabel + == kNoStateId) { + ++compacts_; + --num_arcs_; + has_final_ = true; + } + } + } + + private: + const C *arc_compactor_ = nullptr; // Borrowed reference. + const typename C::Element *compacts_ = nullptr; // Borrowed reference. + StateId s_ = kNoStateId; + U num_arcs_ = 0; + bool has_final_ = false; +}; + +template +class CompactFst; + +template +void Cast(const F &, G *); + +namespace internal { + +// Implementation class for CompactFst, which contains parametrizeable +// Fst data storage (DefaultCompactStore by default) and Fst cache. +template > +class CompactFstImpl + : public CacheBaseImpl { + public: + using Weight = typename Arc::Weight; + using StateId = typename Arc::StateId; + using Compactor = C; + + using FstImpl::SetType; + using FstImpl::SetProperties; + using FstImpl::Properties; + using FstImpl::SetInputSymbols; + using FstImpl::SetOutputSymbols; + using FstImpl::WriteHeader; + + using ImplBase = CacheBaseImpl; + using ImplBase::PushArc; + using ImplBase::HasArcs; + using ImplBase::HasFinal; + using ImplBase::HasStart; + using ImplBase::SetArcs; + using ImplBase::SetFinal; + using ImplBase::SetStart; + + CompactFstImpl() + : ImplBase(CompactFstOptions()), + compactor_() { + SetType(Compactor::Type()); + SetProperties(kNullProperties | kStaticProperties); + } + + CompactFstImpl(const Fst &fst, std::shared_ptr compactor, + const CompactFstOptions &opts) + : ImplBase(opts), + compactor_(std::make_shared(fst, compactor)) { + SetType(Compactor::Type()); + SetInputSymbols(fst.InputSymbols()); + SetOutputSymbols(fst.OutputSymbols()); + if (compactor_->Error()) SetProperties(kError, kError); + uint64 copy_properties = fst.Properties(kMutable, false) ? + fst.Properties(kCopyProperties, true): + CheckProperties(fst, + kCopyProperties & ~kWeightedCycles & ~kUnweightedCycles, + kCopyProperties); + if ((copy_properties & kError) || !compactor_->IsCompatible(fst)) { + FSTERROR() << "CompactFstImpl: Input Fst incompatible with compactor"; + SetProperties(kError, kError); + return; + } + SetProperties(copy_properties | kStaticProperties); + } + + CompactFstImpl(std::shared_ptr compactor, + const CompactFstOptions &opts) + : ImplBase(opts), + compactor_(compactor) { + SetType(Compactor::Type()); + SetProperties(kStaticProperties | compactor_->Properties()); + if (compactor_->Error()) SetProperties(kError, kError); + } + + CompactFstImpl(const CompactFstImpl &impl) + : ImplBase(impl), + compactor_(impl.compactor_ == nullptr ? + std::make_shared() : + std::make_shared(*impl.compactor_)) { + SetType(impl.Type()); + SetProperties(impl.Properties()); + SetInputSymbols(impl.InputSymbols()); + SetOutputSymbols(impl.OutputSymbols()); + } + + // Allows to change the cache store from OtherI to I. + template + CompactFstImpl(const CompactFstImpl &impl) + : ImplBase(CacheOptions(impl.GetCacheGc(), impl.GetCacheLimit())), + compactor_(impl.compactor_ == nullptr ? + std::make_shared() : + std::make_shared(*impl.compactor_)) { + SetType(impl.Type()); + SetProperties(impl.Properties()); + SetInputSymbols(impl.InputSymbols()); + SetOutputSymbols(impl.OutputSymbols()); + } + + StateId Start() { + if (!HasStart()) SetStart(compactor_->Start()); + return ImplBase::Start(); + } + + Weight Final(StateId s) { + if (HasFinal(s)) return ImplBase::Final(s); + compactor_->SetState(s, &state_); + return state_.Final(); + } + + StateId NumStates() const { + if (Properties(kError)) return 0; + return compactor_->NumStates(); + } + + size_t NumArcs(StateId s) { + if (HasArcs(s)) return ImplBase::NumArcs(s); + compactor_->SetState(s, &state_); + return state_.NumArcs(); + } + + size_t NumInputEpsilons(StateId s) { + if (!HasArcs(s) && !Properties(kILabelSorted)) Expand(s); + if (HasArcs(s)) return ImplBase::NumInputEpsilons(s); + return CountEpsilons(s, false); + } + + size_t NumOutputEpsilons(StateId s) { + if (!HasArcs(s) && !Properties(kOLabelSorted)) Expand(s); + if (HasArcs(s)) return ImplBase::NumOutputEpsilons(s); + return CountEpsilons(s, true); + } + + size_t CountEpsilons(StateId s, bool output_epsilons) { + compactor_->SetState(s, &state_); + const uint32 f = output_epsilons ? kArcOLabelValue : kArcILabelValue; + size_t num_eps = 0; + for (size_t i = 0; i < state_.NumArcs(); ++i) { + const auto& arc = state_.GetArc(i, f); + const auto label = output_epsilons ? arc.olabel : arc.ilabel; + if (label == 0) + ++num_eps; + else if (label > 0) + break; + } + return num_eps; + } + + static CompactFstImpl *Read( + std::istream &strm, const FstReadOptions &opts) { + std::unique_ptr> impl( + new CompactFstImpl()); + FstHeader hdr; + if (!impl->ReadHeader(strm, opts, kMinFileVersion, &hdr)) { + return nullptr; + } + // Ensures compatibility. + if (hdr.Version() == kAlignedFileVersion) { + hdr.SetFlags(hdr.GetFlags() | FstHeader::IS_ALIGNED); + } + impl->compactor_ = std::shared_ptr( + Compactor::Read(strm, opts, hdr)); + if (!impl->compactor_) { + return nullptr; + } + return impl.release(); + } + + bool Write(std::ostream &strm, const FstWriteOptions &opts) const { + FstHeader hdr; + hdr.SetStart(compactor_->Start()); + hdr.SetNumStates(compactor_->NumStates()); + hdr.SetNumArcs(compactor_->NumArcs()); + // Ensures compatibility. + const auto file_version = opts.align ? kAlignedFileVersion : kFileVersion; + WriteHeader(strm, opts, file_version, &hdr); + return compactor_->Write(strm, opts); + } + + // Provides information needed for generic state iterator. + void InitStateIterator(StateIteratorData *data) const { + data->base = nullptr; + data->nstates = compactor_->NumStates(); + } + + void InitArcIterator(StateId s, ArcIteratorData *data) { + if (!HasArcs(s)) Expand(s); + ImplBase::InitArcIterator(s, data); + } + + void Expand(StateId s) { + compactor_->SetState(s, &state_); + for (size_t i = 0; i < state_.NumArcs(); ++i) + PushArc(s, state_.GetArc(i, kArcValueFlags)); + SetArcs(s); + if (!HasFinal(s)) SetFinal(s, state_.Final()); + } + + const Compactor *GetCompactor() const { return compactor_.get(); } + std::shared_ptr SharedCompactor() const { return compactor_; } + void SetCompactor(std::shared_ptr compactor) { + // TODO(allauzen): is this correct? is this needed? + // TODO(allauzen): consider removing and forcing this through direct calls + // to compactor. + compactor_ = compactor; + } + + // Properties always true of this FST class. + static constexpr uint64 kStaticProperties = kExpanded; + + protected: + template + explicit CompactFstImpl( + const CompactFstImpl &impl) + : compactor_(std::make_shared(*impl.GetCompactor())) { + SetType(impl.Type()); + SetProperties(impl.Properties()); + SetInputSymbols(impl.InputSymbols()); + SetOutputSymbols(impl.OutputSymbols()); + } + + private: + // Allows access during write. + template + friend class ::fst::CompactFst; // allow access during write. + + // Current unaligned file format version. + static constexpr int kFileVersion = 2; + // Current aligned file format version. + static constexpr int kAlignedFileVersion = 1; + // Minimum file format version supported. + static constexpr int kMinFileVersion = 1; + + std::shared_ptr compactor_; + typename Compactor::State state_; +}; + +template +constexpr uint64 CompactFstImpl::kStaticProperties; + +template +constexpr int CompactFstImpl::kFileVersion; + +template +constexpr int CompactFstImpl::kAlignedFileVersion; + +template +constexpr int CompactFstImpl::kMinFileVersion; + +} // namespace internal + +// This class attaches interface to implementation and handles reference +// counting, delegating most methods to ImplToExpandedFst. The Unsigned type +// is used to represent indices into the compact arc array. (Template +// argument defaults are declared in fst-decl.h.) +template +class CompactFst + : public ImplToExpandedFst, + CacheStore>> { + public: + template + void friend Cast(const F &, G *); + + using Arc = A; + using StateId = typename A::StateId; + using Compactor = DefaultCompactor; + using Impl = internal::CompactFstImpl; + using Store = CacheStore; // for CacheArcIterator + + friend class StateIterator< + CompactFst>; + friend class ArcIterator< + CompactFst>; + + CompactFst() : ImplToExpandedFst(std::make_shared()) {} + + // If data is not nullptr, it is assumed to be already initialized. + explicit CompactFst( + const Fst &fst, + const ArcCompactor &compactor = ArcCompactor(), + const CompactFstOptions &opts = CompactFstOptions(), + std::shared_ptr data = std::shared_ptr()) + : ImplToExpandedFst( + std::make_shared( + fst, + std::make_shared( + std::make_shared(compactor), data), + opts)) {} + + // If data is not nullptr, it is assumed to be already initialized. + CompactFst( + const Fst &fst, + std::shared_ptr compactor, + const CompactFstOptions &opts = CompactFstOptions(), + std::shared_ptr data = std::shared_ptr()) + : ImplToExpandedFst( + std::make_shared(fst, + std::make_shared(compactor, data), + opts)) {} + + // The following 2 constructors take as input two iterators delimiting a set + // of (already) compacted transitions, starting with the transitions out of + // the initial state. The format of the input differs for fixed out-degree + // and variable out-degree compactors. + // + // - For fixed out-degree compactors, the final weight (encoded as a + // compacted transition) needs to be given only for final states. All strings + // (compactor of size 1) will be assume to be terminated by a final state + // even when the final state is not implicitely given. + // + // - For variable out-degree compactors, the final weight (encoded as a + // compacted transition) needs to be given for all states and must appeared + // first in the list (for state s, final weight of s, followed by outgoing + // transitons in s). + // + // These 2 constructors allows the direct construction of a CompactFst + // without first creating a more memory-hungry regular FST. This is useful + // when memory usage is severely constrained. + template + explicit CompactFst(const Iterator &begin, const Iterator &end, + const ArcCompactor &compactor = ArcCompactor(), + const CompactFstOptions &opts = CompactFstOptions()) + : ImplToExpandedFst( + std::make_shared( + std::make_shared( + begin, end, std::make_shared(compactor)), + opts)) {} + + template + CompactFst(const Iterator &begin, const Iterator &end, + std::shared_ptr compactor, + const CompactFstOptions &opts = CompactFstOptions()) + : ImplToExpandedFst( + std::make_shared( + std::make_shared(begin, end, compactor), opts)) {} + + // See Fst<>::Copy() for doc. + CompactFst( + const CompactFst + &fst, + bool safe = false) + : ImplToExpandedFst(fst, safe) {} + + // Get a copy of this CompactFst. See Fst<>::Copy() for further doc. + CompactFst *Copy( + bool safe = false) const override { + return new CompactFst( + *this, safe); + } + + // Read a CompactFst from an input stream; return nullptr on error + static CompactFst *Read( + std::istream &strm, const FstReadOptions &opts) { + auto *impl = Impl::Read(strm, opts); + return impl ? new CompactFst(std::shared_ptr(impl)) + : nullptr; + } + + // Read a CompactFst from a file; return nullptr on error + // Empty filename reads from standard input + static CompactFst *Read( + const string &filename) { + auto *impl = ImplToExpandedFst::Read(filename); + return impl ? new CompactFst(std::shared_ptr(impl)) + : nullptr; + } + + bool Write(std::ostream &strm, const FstWriteOptions &opts) const override { + return GetImpl()->Write(strm, opts); + } + + bool Write(const string &filename) const override { + return Fst::WriteFile(filename); + } + + template + static bool WriteFst(const FST &fst, const ArcCompactor &compactor, + std::ostream &strm, const FstWriteOptions &opts); + + void InitStateIterator(StateIteratorData *data) const override { + GetImpl()->InitStateIterator(data); + } + + void InitArcIterator(StateId s, ArcIteratorData *data) const override { + GetMutableImpl()->InitArcIterator(s, data); + } + + MatcherBase *InitMatcher(MatchType match_type) const override { + return new SortedMatcher< + CompactFst>( + *this, match_type); + } + + template + void SetCompactElements(const Iterator &b, const Iterator &e) { + GetMutableImpl()->SetCompactor(std::make_shared( + b, e, std::make_shared())); + } + + private: + using ImplToFst>::GetImpl; + using ImplToFst>::GetMutableImpl; + + explicit CompactFst(std::shared_ptr impl) + : ImplToExpandedFst(impl) {} + + // Use overloading to extract the type of the argument. + static Impl *GetImplIfCompactFst( + const CompactFst + &compact_fst) { + return compact_fst.GetImpl(); + } + + // This does not give privileged treatment to subclasses of CompactFst. + template + static Impl *GetImplIfCompactFst(const NonCompactFst &fst) { + return nullptr; + } + + CompactFst &operator=(const CompactFst &fst) = delete; +}; + +// Writes FST in Compact format, with a possible pass over the machine before +// writing to compute the number of states and arcs. +template +template +bool CompactFst::WriteFst( + const FST &fst, const ArcCompactor &compactor, std::ostream &strm, + const FstWriteOptions &opts) { + using Arc = A; + using Weight = typename A::Weight; + using Element = typename ArcCompactor::Element; + const auto file_version = + opts.align ? Impl::kAlignedFileVersion : Impl::kFileVersion; + size_t num_arcs = -1; + size_t num_states = -1; + auto first_pass_compactor = compactor; + if (auto *impl = GetImplIfCompactFst(fst)) { + num_arcs = impl->GetCompactor()->GetCompactStore()->NumArcs(); + num_states = impl->GetCompactor()->GetCompactStore()->NumStates(); + first_pass_compactor = *impl->GetCompactor()->GetArcCompactor(); + } else { + // A first pass is needed to compute the state of the compactor, which + // is saved ahead of the rest of the data structures. This unfortunately + // means forcing a complete double compaction when writing in this format. + // TODO(allauzen): eliminate mutable state from compactors. + num_arcs = 0; + num_states = 0; + for (StateIterator siter(fst); !siter.Done(); siter.Next()) { + const auto s = siter.Value(); + ++num_states; + if (fst.Final(s) != Weight::Zero()) { + first_pass_compactor.Compact( + s, Arc(kNoLabel, kNoLabel, fst.Final(s), kNoStateId)); + } + for (ArcIterator aiter(fst, s); !aiter.Done(); aiter.Next()) { + ++num_arcs; + first_pass_compactor.Compact(s, aiter.Value()); + } + } + } + FstHeader hdr; + hdr.SetStart(fst.Start()); + hdr.SetNumStates(num_states); + hdr.SetNumArcs(num_arcs); + string type = "compact"; + if (sizeof(Unsigned) != sizeof(uint32)) { + type += std::to_string(CHAR_BIT * sizeof(Unsigned)); + } + type += "_"; + type += ArcCompactor::Type(); + if (CompactStore::Type() != "compact") { + type += "_"; + type += CompactStore::Type(); + } + const auto copy_properties = fst.Properties(kCopyProperties, true); + if ((copy_properties & kError) || !compactor.Compatible(fst)) { + FSTERROR() << "Fst incompatible with compactor"; + return false; + } + uint64 properties = copy_properties | Impl::kStaticProperties; + internal::FstImpl::WriteFstHeader(fst, strm, opts, file_version, type, + properties, &hdr); + first_pass_compactor.Write(strm); + if (first_pass_compactor.Size() == -1) { + if (opts.align && !AlignOutput(strm)) { + LOG(ERROR) << "CompactFst::Write: Alignment failed: " << opts.source; + return false; + } + Unsigned compacts = 0; + for (StateIterator siter(fst); !siter.Done(); siter.Next()) { + const auto s = siter.Value(); + strm.write(reinterpret_cast(&compacts), sizeof(compacts)); + if (fst.Final(s) != Weight::Zero()) { + ++compacts; + } + compacts += fst.NumArcs(s); + } + strm.write(reinterpret_cast(&compacts), sizeof(compacts)); + } + if (opts.align && !AlignOutput(strm)) { + LOG(ERROR) << "Could not align file during write after writing states"; + } + const auto &second_pass_compactor = compactor; + Element element; + for (StateIterator siter(fst); !siter.Done(); siter.Next()) { + const auto s = siter.Value(); + if (fst.Final(s) != Weight::Zero()) { + element = second_pass_compactor.Compact( + s, A(kNoLabel, kNoLabel, fst.Final(s), kNoStateId)); + strm.write(reinterpret_cast(&element), sizeof(element)); + } + for (ArcIterator aiter(fst, s); !aiter.Done(); aiter.Next()) { + element = second_pass_compactor.Compact(s, aiter.Value()); + strm.write(reinterpret_cast(&element), sizeof(element)); + } + } + strm.flush(); + if (!strm) { + LOG(ERROR) << "CompactFst write failed: " << opts.source; + return false; + } + return true; +} + +// Specialization for CompactFst; see generic version in fst.h for sample +// usage (but use the CompactFst type!). This version should inline. +template +class StateIterator< + CompactFst> { + public: + using StateId = typename Arc::StateId; + + explicit StateIterator( + const CompactFst &fst) + : nstates_(fst.GetImpl()->NumStates()), s_(0) {} + + bool Done() const { return s_ >= nstates_; } + + StateId Value() const { return s_; } + + void Next() { ++s_; } + + void Reset() { s_ = 0; } + + private: + StateId nstates_; + StateId s_; +}; + +// Specialization for CompactFst. Never caches, +// always iterates over the underlying compact elements. +template +class ArcIterator> { + public: + using StateId = typename Arc::StateId; + using Element = typename ArcCompactor::Element; + using Compactor = DefaultCompactor; + using State = typename Compactor::State; + + ArcIterator(const CompactFst &fst, + StateId s) + : state_(fst.GetImpl()->GetCompactor(), s), + pos_(0), + flags_(kArcValueFlags) {} + + bool Done() const { return pos_ >= state_.NumArcs(); } + + const Arc &Value() const { + arc_ = state_.GetArc(pos_, flags_); + return arc_; + } + + void Next() { ++pos_; } + + size_t Position() const { return pos_; } + + void Reset() { pos_ = 0; } + + void Seek(size_t pos) { pos_ = pos; } + + uint32 Flags() const { return flags_; } + + void SetFlags(uint32 f, uint32 m) { + flags_ &= ~m; + flags_ |= (f & kArcValueFlags); + } + + private: + State state_; + size_t pos_; + mutable Arc arc_; + uint32 flags_; +}; + +// ArcCompactor for unweighted string FSTs. +template +class StringCompactor { + public: + using Arc = A; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using Element = Label; + + Element Compact(StateId s, const Arc &arc) const { return arc.ilabel; } + + Arc Expand(StateId s, const Element &p, uint32 f = kArcValueFlags) const { + return Arc(p, p, Weight::One(), p != kNoLabel ? s + 1 : kNoStateId); + } + + constexpr ssize_t Size() const { return 1; } + + constexpr uint64 Properties() const { + return kString | kAcceptor | kUnweighted; + } + + bool Compatible(const Fst &fst) const { + const auto props = Properties(); + return fst.Properties(props, true) == props; + } + + static const string &Type() { + static const string *const type = new string("string"); + return *type; + } + + bool Write(std::ostream &strm) const { return true; } + + static StringCompactor *Read(std::istream &strm) { + return new StringCompactor; + } +}; + +// ArcCompactor for weighted string FSTs. +template +class WeightedStringCompactor { + public: + using Arc = A; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using Element = std::pair; + + Element Compact(StateId s, const Arc &arc) const { + return std::make_pair(arc.ilabel, arc.weight); + } + + Arc Expand(StateId s, const Element &p, uint32 f = kArcValueFlags) const { + return Arc(p.first, p.first, p.second, + p.first != kNoLabel ? s + 1 : kNoStateId); + } + + constexpr ssize_t Size() const { return 1; } + + constexpr uint64 Properties() const { return kString | kAcceptor; } + + bool Compatible(const Fst &fst) const { + const auto props = Properties(); + return fst.Properties(props, true) == props; + } + + static const string &Type() { + static const string *const type = new string("weighted_string"); + return *type; + } + + bool Write(std::ostream &strm) const { return true; } + + static WeightedStringCompactor *Read(std::istream &strm) { + return new WeightedStringCompactor; + } +}; + +// ArcCompactor for unweighted acceptor FSTs. +template +class UnweightedAcceptorCompactor { + public: + using Arc = A; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using Element = std::pair; + + Element Compact(StateId s, const Arc &arc) const { + return std::make_pair(arc.ilabel, arc.nextstate); + } + + Arc Expand(StateId s, const Element &p, uint32 f = kArcValueFlags) const { + return Arc(p.first, p.first, Weight::One(), p.second); + } + + constexpr ssize_t Size() const { return -1; } + + constexpr uint64 Properties() const { return kAcceptor | kUnweighted; } + + bool Compatible(const Fst &fst) const { + const auto props = Properties(); + return fst.Properties(props, true) == props; + } + + static const string &Type() { + static const string *const type = new string("unweighted_acceptor"); + return *type; + } + + bool Write(std::ostream &strm) const { return true; } + + static UnweightedAcceptorCompactor *Read(std::istream &istrm) { + return new UnweightedAcceptorCompactor; + } +}; + +// ArcCompactor for weighted acceptor FSTs. +template +class AcceptorCompactor { + public: + using Arc = A; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using Element = std::pair, StateId>; + + Element Compact(StateId s, const Arc &arc) const { + return std::make_pair(std::make_pair(arc.ilabel, arc.weight), + arc.nextstate); + } + + Arc Expand(StateId s, const Element &p, uint32 f = kArcValueFlags) const { + return Arc(p.first.first, p.first.first, p.first.second, p.second); + } + + constexpr ssize_t Size() const { return -1; } + + constexpr uint64 Properties() const { return kAcceptor; } + + bool Compatible(const Fst &fst) const { + const auto props = Properties(); + return fst.Properties(props, true) == props; + } + + static const string &Type() { + static const string *const type = new string("acceptor"); + return *type; + } + + bool Write(std::ostream &strm) const { return true; } + + static AcceptorCompactor *Read(std::istream &strm) { + return new AcceptorCompactor; + } +}; + +// ArcCompactor for unweighted FSTs. +template +class UnweightedCompactor { + public: + using Arc = A; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using Element = std::pair, StateId>; + + Element Compact(StateId s, const Arc &arc) const { + return std::make_pair(std::make_pair(arc.ilabel, arc.olabel), + arc.nextstate); + } + + Arc Expand(StateId s, const Element &p, uint32 f = kArcValueFlags) const { + return Arc(p.first.first, p.first.second, Weight::One(), p.second); + } + + constexpr ssize_t Size() const { return -1; } + + constexpr uint64 Properties() const { return kUnweighted; } + + bool Compatible(const Fst &fst) const { + const auto props = Properties(); + return fst.Properties(props, true) == props; + } + + static const string &Type() { + static const string *const type = new string("unweighted"); + return *type; + } + + bool Write(std::ostream &strm) const { return true; } + + static UnweightedCompactor *Read(std::istream &strm) { + return new UnweightedCompactor; + } +}; + +template +using CompactStringFst = CompactFst, Unsigned>; + +template +using CompactWeightedStringFst = + CompactFst, Unsigned>; + +template +using CompactAcceptorFst = CompactFst, Unsigned>; + +template +using CompactUnweightedFst = + CompactFst, Unsigned>; + +template +using CompactUnweightedAcceptorFst = + CompactFst, Unsigned>; + +using StdCompactStringFst = CompactStringFst; + +using StdCompactWeightedStringFst = CompactWeightedStringFst; + +using StdCompactAcceptorFst = CompactAcceptorFst; + +using StdCompactUnweightedFst = CompactUnweightedFst; + +using StdCompactUnweightedAcceptorFst = + CompactUnweightedAcceptorFst; + +} // namespace fst + +#endif // FST_COMPACT_FST_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/compat.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/compat.h new file mode 100644 index 0000000000..fc95b12005 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/compat.h @@ -0,0 +1,105 @@ +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_LIB_COMPAT_H_ +#define FST_LIB_COMPAT_H_ + +#include +#include +#include +#include +#include +#include + +// Makes copy constructor and operator= private +// Deprecated: now just use =delete. +#define DISALLOW_COPY_AND_ASSIGN(type) \ + type(const type&); \ + void operator=(const type&) + +#if defined(__GNUC__) || defined(__clang__) +#define OPENFST_DEPRECATED(message) __attribute__((deprecated(message))) +#elif defined(_MSC_VER) +#define OPENFST_DEPRECATED(message) __declspec(deprecated(message)) +#else +#define OPENFST_DEPRECATED(message) +#endif + +#include +#include +#include +#include +#include +#include + +using std::string; + +void FailedNewHandler(); + +namespace fst { + +// Downcasting. +template +inline To down_cast(From* f) { return static_cast(f); } + +// Bitcasting. +template +inline Dest bit_cast(const Source &source) { + static_assert(sizeof(Dest) == sizeof(Source), + "Bitcasting unsafe for specified types"); + Dest dest; + memcpy(&dest, &source, sizeof(dest)); + return dest; +} + +// Check sums +class CheckSummer { + public: + CheckSummer() : count_(0) { + check_sum_.resize(kCheckSumLength, '\0'); + } + + void Reset() { + count_ = 0; + for (int i = 0; i < kCheckSumLength; ++i) check_sum_[i] = '\0'; + } + + void Update(void const *data, int size) { + const char *p = reinterpret_cast(data); + for (int i = 0; i < size; ++i) { + check_sum_[(count_++) % kCheckSumLength] ^= p[i]; + } + } + + void Update(string const &data) { + for (int i = 0; i < data.size(); ++i) { + check_sum_[(count_++) % kCheckSumLength] ^= data[i]; + } + } + + string Digest() { return check_sum_; } + + private: + static const int kCheckSumLength = 32; + int count_; + string check_sum_; + + CheckSummer(const CheckSummer &) = delete; + CheckSummer &operator=(const CheckSummer &) = delete; +}; + +} // namespace fst + +#endif // FST_LIB_COMPAT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/complement.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/complement.h new file mode 100644 index 0000000000..64eebc03f3 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/complement.h @@ -0,0 +1,277 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Class to complement an FST. + +#ifndef FST_COMPLEMENT_H_ +#define FST_COMPLEMENT_H_ + +#include +#include +#include +#include + +#include +#include + + +namespace fst { + +template +class ComplementFst; + +namespace internal { + +// Implementation of delayed ComplementFst. The algorithm used completes the +// (deterministic) FSA and then exchanges final and non-final states. +// Completion, i.e. ensuring that all labels can be read from every state, is +// accomplished by using ρ-labels, which match all labels that are otherwise +// not found leaving a state. The first state in the output is reserved to be a +// new state that is the destination of all ρ-labels. Each remaining output +// state s corresponds to input state s - 1. The first arc in the output at +// these states is the ρ-label, the remaining arcs correspond to the input +// arcs. +template +class ComplementFstImpl : public FstImpl { + public: + using Arc = A; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using FstImpl::SetType; + using FstImpl::SetProperties; + using FstImpl::SetInputSymbols; + using FstImpl::SetOutputSymbols; + + friend class StateIterator>; + friend class ArcIterator>; + + explicit ComplementFstImpl(const Fst &fst) : fst_(fst.Copy()) { + SetType("complement"); + uint64 props = fst.Properties(kILabelSorted, false); + SetProperties(ComplementProperties(props), kCopyProperties); + SetInputSymbols(fst.InputSymbols()); + SetOutputSymbols(fst.OutputSymbols()); + } + + ComplementFstImpl(const ComplementFstImpl &impl) + : fst_(impl.fst_->Copy()) { + SetType("complement"); + SetProperties(impl.Properties(), kCopyProperties); + SetInputSymbols(impl.InputSymbols()); + SetOutputSymbols(impl.OutputSymbols()); + } + + StateId Start() const { + if (Properties(kError)) return kNoStateId; + auto start = fst_->Start(); + return start != kNoStateId ? start + 1 : 0; + } + + // Exchange final and non-final states; makes ρ-destination state final. + Weight Final(StateId s) const { + if (s == 0 || fst_->Final(s - 1) == Weight::Zero()) { + return Weight::One(); + } else { + return Weight::Zero(); + } + } + + size_t NumArcs(StateId s) const { + return s == 0 ? 1 : fst_->NumArcs(s - 1) + 1; + } + + size_t NumInputEpsilons(StateId s) const { + return s == 0 ? 0 : fst_->NumInputEpsilons(s - 1); + } + + size_t NumOutputEpsilons(StateId s) const { + return s == 0 ? 0 : fst_->NumOutputEpsilons(s - 1); + } + + uint64 Properties() const override { return Properties(kFstProperties); } + + // Sets error if found, and returns other FST impl properties. + uint64 Properties(uint64 mask) const override { + if ((mask & kError) && fst_->Properties(kError, false)) { + SetProperties(kError, kError); + } + return FstImpl::Properties(mask); + } + + private: + std::unique_ptr> fst_; +}; + +} // namespace internal + +// Complements an automaton. This is a library-internal operation that +// introduces a (negative) ρ-label; use Difference/DifferenceFst in user code, +// which will not see this label. This version is a delayed FST. +// +// This class attaches interface to implementation and handles +// reference counting, delegating most methods to ImplToFst. +template +class ComplementFst : public ImplToFst> { + public: + using Arc = A; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Impl = internal::ComplementFstImpl; + + friend class StateIterator>; + friend class ArcIterator>; + + explicit ComplementFst(const Fst &fst) + : ImplToFst(std::make_shared(fst)) { + static constexpr auto props = + kUnweighted | kNoEpsilons | kIDeterministic | kAcceptor; + if (fst.Properties(props, true) != props) { + FSTERROR() << "ComplementFst: Argument not an unweighted " + << "epsilon-free deterministic acceptor"; + GetImpl()->SetProperties(kError, kError); + } + } + + // See Fst<>::Copy() for doc. + ComplementFst(const ComplementFst &fst, bool safe = false) + : ImplToFst(fst, safe) {} + + // Gets a copy of this FST. See Fst<>::Copy() for further doc. + ComplementFst *Copy(bool safe = false) const override { + return new ComplementFst(*this, safe); + } + + inline void InitStateIterator(StateIteratorData *data) const override; + + inline void InitArcIterator(StateId s, + ArcIteratorData *data) const override; + + // Label that represents the ρ-transition; we use a negative value private to + // the library and which will preserve FST label sort order. + static const Label kRhoLabel = -2; + + private: + using ImplToFst::GetImpl; + + ComplementFst &operator=(const ComplementFst &) = delete; +}; + +template +const typename Arc::Label ComplementFst::kRhoLabel; + +// Specialization for ComplementFst. +template +class StateIterator> : public StateIteratorBase { + public: + using StateId = typename Arc::StateId; + + explicit StateIterator(const ComplementFst &fst) + : siter_(*fst.GetImpl()->fst_), s_(0) {} + + bool Done() const final { return s_ > 0 && siter_.Done(); } + + StateId Value() const final { return s_; } + + void Next() final { + if (s_ != 0) siter_.Next(); + ++s_; + } + + void Reset() final { + siter_.Reset(); + s_ = 0; + } + + private: + StateIterator> siter_; + StateId s_; +}; + +// Specialization for ComplementFst. +template +class ArcIterator> : public ArcIteratorBase { + public: + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + ArcIterator(const ComplementFst &fst, StateId s) : s_(s), pos_(0) { + if (s_ != 0) { + aiter_.reset(new ArcIterator>(*fst.GetImpl()->fst_, s - 1)); + } + } + + bool Done() const final { + if (s_ != 0) { + return pos_ > 0 && aiter_->Done(); + } else { + return pos_ > 0; + } + } + + // Adds the ρ-label to the ρ destination state. + const Arc &Value() const final { + if (pos_ == 0) { + arc_.ilabel = arc_.olabel = ComplementFst::kRhoLabel; + arc_.weight = Weight::One(); + arc_.nextstate = 0; + } else { + arc_ = aiter_->Value(); + ++arc_.nextstate; + } + return arc_; + } + + void Next() final { + if (s_ != 0 && pos_ > 0) aiter_->Next(); + ++pos_; + } + + size_t Position() const final { return pos_; } + + void Reset() final { + if (s_ != 0) aiter_->Reset(); + pos_ = 0; + } + + void Seek(size_t a) final { + if (s_ != 0) { + if (a == 0) { + aiter_->Reset(); + } else { + aiter_->Seek(a - 1); + } + } + pos_ = a; + } + + uint32 Flags() const final { return kArcValueFlags; } + + void SetFlags(uint32, uint32) final {} + + private: + std::unique_ptr>> aiter_; + StateId s_; + size_t pos_; + mutable Arc arc_; +}; + +template +inline void ComplementFst::InitStateIterator( + StateIteratorData *data) const { + data->base = new StateIterator>(*this); +} + +template +inline void ComplementFst::InitArcIterator(StateId s, + ArcIteratorData *data) const { + data->base = new ArcIterator>(*this, s); +} + +// Useful alias when using StdArc. +using StdComplementFst = ComplementFst; + +} // namespace fst + +#endif // FST_COMPLEMENT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/compose-filter.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/compose-filter.h new file mode 100644 index 0000000000..72b79bcee7 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/compose-filter.h @@ -0,0 +1,508 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Classes for filtering the composition matches, e.g. for correct epsilon +// handling. + +#ifndef FST_COMPOSE_FILTER_H_ +#define FST_COMPOSE_FILTER_H_ + +#include +#include // For optional argument declarations +#include +#include + + +namespace fst { + +// Composition filters determine which matches are allowed to proceed. The +// filter's state is represeted by the type ComposeFilter::FilterState. +// The basic filters handle correct epsilon matching. Their interface is: +// +// template +// class ComposeFilter { +// public: +// using Matcher1 = ...; +// using Matcher2 = ...; +// using FST1 = typename M1::FST; +// using FST2 = typename M2::FST; +// using FilterState = ...; +// +// using Arc = typename FST1::Arc; +// using StateId = typename Arc::StateId; +// using Weight = typename Arc::Weight; +// +// // Required constructor. +// ComposeFilter(const FST1 &fst1, const FST2 &fst2, +// M1 *matcher1 = nullptr, M2 *matcher2 = nullptr); +// +// // If safe=true, the copy is thread-safe. See Fst<>::Copy() +// // for further doc. +// ComposeFilter(const ComposeFilter &filter, +// bool safe = false); +// +// // Return start state of filter. +// FilterState Start() const; +// +// // Specifies current composition state. +// void SetState(StateId s1, StateId s2, const FilterState &fs); +// +// // Apply filter at current composition state to these transitions. If an +// // arc label to be matched is kNolabel, then that side does not consume a +// // symbol. Returns the new filter state or, if disallowed, +// // FilterState::NoState(). The filter is permitted to modify its inputs +// // (e.g. for optimization reasons). +// FilterState FilterArc(Arc *arc1, Arc *arc2) const; + +// // Apply filter at current composition state to these final weights +// // (cf. superfinal transitions). The filter may modify its inputs +// // (e.g. for optimization reasons). +// void FilterFinal(Weight *w1, Weight *w2) const; +// +// // Return the respective matchers. Ownership stays with filter. These +// // methods allow the filter to access and possibly modify the compositio +// // matchers (useful, e.g., with lookahead). +// +// Matcher1 *GetMatcher1(); +// +// Matcher2 *GetMatcher2(); +// +// // This specifies how the filter affects the composition result properties. +// It takes as argument the properties that would apply with a trivial +// // composition filter. +// uint64 Properties(uint64 props) const; +// }; +// +// This filter allows only exact matching of symbols from FST1 with on FST2; +// e.g., no special interpretation of epsilons. +template +class NullComposeFilter { + public: + using Matcher1 = M1; + using Matcher2 = M2; + using FST1 = typename M1::FST; + using FST2 = typename M2::FST; + using FilterState = TrivialFilterState; + + using Arc = typename FST1::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + NullComposeFilter(const FST1 &fst1, const FST2 &fst2, + Matcher1 *matcher1 = nullptr, Matcher2 *matcher2 = nullptr) + : matcher1_(matcher1 ? matcher1 : new Matcher1(fst1, MATCH_OUTPUT)), + matcher2_(matcher2 ? matcher2 : new Matcher2(fst2, MATCH_INPUT)), + fst1_(matcher1_->GetFst()), + fst2_(matcher2_->GetFst()) {} + + NullComposeFilter(const NullComposeFilter &filter, bool safe = false) + : matcher1_(filter.matcher1_->Copy(safe)), + matcher2_(filter.matcher2_->Copy(safe)), + fst1_(matcher1_->GetFst()), + fst2_(matcher2_->GetFst()) {} + + FilterState Start() const { return FilterState(true); } + + void SetState(StateId, StateId, const FilterState &) {} + + FilterState FilterArc(Arc *arc1, Arc *arc2) const { + return (arc1->olabel == kNoLabel || arc2->ilabel == kNoLabel) + ? FilterState::NoState() + : FilterState(true); + } + + void FilterFinal(Weight *, Weight *) const {} + + Matcher1 *GetMatcher1() { return matcher1_.get(); } + + Matcher2 *GetMatcher2() { return matcher2_.get(); } + + uint64 Properties(uint64 props) const { return props; } + + private: + std::unique_ptr matcher1_; + std::unique_ptr matcher2_; + const FST1 &fst1_; + const FST2 &fst2_; +}; + +// This filter allows all epsilon matches, potentially resulting in redundant +// epsilon paths. The use of this filter gives correct results iff one of the +// following conditions hold: +// +// (1) The semiring is idempotent, +// (2) the first FST is output-epsilon free, or +// (3) the second FST is input-epsilon free. +// +// For (1), redundant epsilon paths may be created but won't hurt correctness. +// For (2) and (3), no redundant paths are created. +template +class TrivialComposeFilter { + public: + using Matcher1 = M1; + using Matcher2 = M2; + using FST1 = typename M1::FST; + using FST2 = typename M2::FST; + using FilterState = TrivialFilterState; + + using Arc = typename FST1::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + TrivialComposeFilter(const FST1 &fst1, const FST2 &fst2, + Matcher1 *matcher1 = nullptr, + Matcher2 *matcher2 = nullptr) + : matcher1_(matcher1 ? matcher1 : new Matcher1(fst1, MATCH_OUTPUT)), + matcher2_(matcher2 ? matcher2 : new Matcher2(fst2, MATCH_INPUT)), + fst1_(matcher1_->GetFst()), + fst2_(matcher2_->GetFst()) {} + + TrivialComposeFilter(const TrivialComposeFilter &filter, + bool safe = false) + : matcher1_(filter.matcher1_->Copy(safe)), + matcher2_(filter.matcher2_->Copy(safe)), + fst1_(matcher1_->GetFst()), + fst2_(matcher2_->GetFst()) {} + + FilterState Start() const { return FilterState(true); } + + void SetState(StateId, StateId, const FilterState &) {} + + FilterState FilterArc(Arc *, Arc *) const { return FilterState(true); } + + void FilterFinal(Weight *, Weight *) const {} + + Matcher1 *GetMatcher1() { return matcher1_.get(); } + + Matcher2 *GetMatcher2() { return matcher2_.get(); } + + uint64 Properties(uint64 props) const { return props; } + + private: + std::unique_ptr matcher1_; + std::unique_ptr matcher2_; + const FST1 &fst1_; + const FST2 &fst2_; +}; + +// This filter requires epsilons on FST1 to be read before epsilons on FST2. +template +class SequenceComposeFilter { + public: + using Matcher1 = M1; + using Matcher2 = M2; + using FST1 = typename M1::FST; + using FST2 = typename M2::FST; + using FilterState = CharFilterState; + + using Arc = typename FST1::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + SequenceComposeFilter(const FST1 &fst1, const FST2 &fst2, + Matcher1 *matcher1 = nullptr, + Matcher2 *matcher2 = nullptr) + : matcher1_(matcher1 ? matcher1 : new Matcher1(fst1, MATCH_OUTPUT)), + matcher2_(matcher2 ? matcher2 : new Matcher2(fst2, MATCH_INPUT)), + fst1_(matcher1_->GetFst()), + s1_(kNoStateId), + s2_(kNoStateId), + fs_(kNoStateId) {} + + SequenceComposeFilter(const SequenceComposeFilter &filter, + bool safe = false) + : matcher1_(filter.matcher1_->Copy(safe)), + matcher2_(filter.matcher2_->Copy(safe)), + fst1_(matcher1_->GetFst()), + s1_(kNoStateId), + s2_(kNoStateId), + fs_(kNoStateId) {} + + FilterState Start() const { return FilterState(0); } + + void SetState(StateId s1, StateId s2, const FilterState &fs) { + if (s1_ == s1 && s2_ == s2 && fs == fs_) return; + s1_ = s1; + s2_ = s2; + fs_ = fs; + const auto na1 = internal::NumArcs(fst1_, s1); + const auto ne1 = internal::NumOutputEpsilons(fst1_, s1); + const bool fin1 = internal::Final(fst1_, s1) != Weight::Zero(); + alleps1_ = na1 == ne1 && !fin1; + noeps1_ = ne1 == 0; + } + + FilterState FilterArc(Arc *arc1, Arc *arc2) const { + if (arc1->olabel == kNoLabel) { + return alleps1_ ? FilterState::NoState() : noeps1_ ? FilterState(0) + : FilterState(1); + } else if (arc2->ilabel == kNoLabel) { + return fs_ != FilterState(0) ? FilterState::NoState() : FilterState(0); + } else { + return arc1->olabel == 0 ? FilterState::NoState() : FilterState(0); + } + } + + void FilterFinal(Weight *, Weight *) const {} + + Matcher1 *GetMatcher1() { return matcher1_.get(); } + + Matcher2 *GetMatcher2() { return matcher2_.get(); } + + uint64 Properties(uint64 props) const { return props; } + + private: + std::unique_ptr matcher1_; + std::unique_ptr matcher2_; + const FST1 &fst1_; + StateId s1_; // Current fst1_ state. + StateId s2_; // Current fst2_ state. + FilterState fs_; // Current filter state. + bool alleps1_; // Only epsilons (and non-final) leaving s1_? + bool noeps1_; // No epsilons leaving s1_? +}; + +// This filter requires epsilons on FST2 to be read before epsilons on FST1. +template +class AltSequenceComposeFilter { + public: + using Matcher1 = M1; + using Matcher2 = M2; + using FST1 = typename M1::FST; + using FST2 = typename M2::FST; + using FilterState = CharFilterState; + + using Arc = typename FST1::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + AltSequenceComposeFilter(const FST1 &fst1, const FST2 &fst2, + Matcher1 *matcher1 = nullptr, + Matcher2 *matcher2 = nullptr) + : matcher1_(matcher1 ? matcher1 : new Matcher1(fst1, MATCH_OUTPUT)), + matcher2_(matcher2 ? matcher2 : new Matcher2(fst2, MATCH_INPUT)), + fst2_(matcher2_->GetFst()), + s1_(kNoStateId), + s2_(kNoStateId), + fs_(kNoStateId) {} + + AltSequenceComposeFilter( + const AltSequenceComposeFilter &filter, + bool safe = false) + : matcher1_(filter.matcher1_->Copy(safe)), + matcher2_(filter.matcher2_->Copy(safe)), + fst2_(matcher2_->GetFst()), + s1_(kNoStateId), + s2_(kNoStateId), + fs_(kNoStateId) {} + + FilterState Start() const { return FilterState(0); } + + void SetState(StateId s1, StateId s2, const FilterState &fs) { + if (s1_ == s1 && s2_ == s2 && fs == fs_) return; + s1_ = s1; + s2_ = s2; + fs_ = fs; + const auto na2 = internal::NumArcs(fst2_, s2); + const auto ne2 = internal::NumInputEpsilons(fst2_, s2); + const bool fin2 = internal::Final(fst2_, s2) != Weight::Zero(); + alleps2_ = na2 == ne2 && !fin2; + noeps2_ = ne2 == 0; + } + + FilterState FilterArc(Arc *arc1, Arc *arc2) const { + if (arc2->ilabel == kNoLabel) { + return alleps2_ ? FilterState::NoState() : noeps2_ ? FilterState(0) + : FilterState(1); + } else if (arc1->olabel == kNoLabel) { + return fs_ == FilterState(1) ? FilterState::NoState() : FilterState(0); + } else { + return arc1->olabel == 0 ? FilterState::NoState() : FilterState(0); + } + } + + void FilterFinal(Weight *, Weight *) const {} + + Matcher1 *GetMatcher1() { return matcher1_.get(); } + + Matcher2 *GetMatcher2() { return matcher2_.get(); } + + uint64 Properties(uint64 props) const { return props; } + + private: + std::unique_ptr matcher1_; + std::unique_ptr matcher2_; + const FST2 &fst2_; + StateId s1_; // Current fst1_ state. + StateId s2_; // Current fst2_ state. + FilterState fs_; // Current filter state. + bool alleps2_; // Only epsilons (and non-final) leaving s2_? + bool noeps2_; // No epsilons leaving s2_? +}; + +// This filter requires epsilons on FST1 to be matched with epsilons on FST2 +// whenever possible. (Template arg default declared in fst-decl.h.) +template +class MatchComposeFilter { + public: + using Matcher1 = M1; + using Matcher2 = M2; + using FST1 = typename M1::FST; + using FST2 = typename M2::FST; + using FilterState = CharFilterState; + + using Arc = typename FST1::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + MatchComposeFilter(const FST1 &fst1, const FST2 &fst2, + Matcher1 *matcher1 = nullptr, Matcher2 *matcher2 = nullptr) + : matcher1_(matcher1 ? matcher1 : new Matcher1(fst1, MATCH_OUTPUT)), + matcher2_(matcher2 ? matcher2 : new Matcher2(fst2, MATCH_INPUT)), + fst1_(matcher1_->GetFst()), + fst2_(matcher2_->GetFst()), + s1_(kNoStateId), + s2_(kNoStateId), + fs_(kNoStateId) {} + + MatchComposeFilter(const MatchComposeFilter &filter, + bool safe = false) + : matcher1_(filter.matcher1_->Copy(safe)), + matcher2_(filter.matcher2_->Copy(safe)), + fst1_(matcher1_->GetFst()), + fst2_(matcher2_->GetFst()), + s1_(kNoStateId), + s2_(kNoStateId), + fs_(kNoStateId) {} + + FilterState Start() const { return FilterState(0); } + + void SetState(StateId s1, StateId s2, const FilterState &fs) { + if (s1_ == s1 && s2_ == s2 && fs == fs_) return; + s1_ = s1; + s2_ = s2; + fs_ = fs; + size_t na1 = internal::NumArcs(fst1_, s1); + size_t ne1 = internal::NumOutputEpsilons(fst1_, s1); + bool f1 = internal::Final(fst1_, s1) != Weight::Zero(); + alleps1_ = na1 == ne1 && !f1; + noeps1_ = ne1 == 0; + size_t na2 = internal::NumArcs(fst2_, s2); + size_t ne2 = internal::NumInputEpsilons(fst2_, s2); + bool f2 = internal::Final(fst2_, s2) != Weight::Zero(); + alleps2_ = na2 == ne2 && !f2; + noeps2_ = ne2 == 0; + } + + FilterState FilterArc(Arc *arc1, Arc *arc2) const { + if (arc2->ilabel == kNoLabel) { // Epsilon in FST1. + return fs_ == FilterState(0) + ? (noeps2_ + ? FilterState(0) + : (alleps2_ ? FilterState::NoState() : FilterState(1))) + : (fs_ == FilterState(1) ? FilterState(1) + : FilterState::NoState()); + } else if (arc1->olabel == kNoLabel) { // Epsilon in FST2. + return fs_ == FilterState(0) + ? (noeps1_ + ? FilterState(0) + : (alleps1_ ? FilterState::NoState() : FilterState(2))) + : (fs_ == FilterState(2) ? FilterState(2) + : FilterState::NoState()); + } else if (arc1->olabel == 0) { // Epsilon in both. + return fs_ == FilterState(0) ? FilterState(0) : FilterState::NoState(); + } else { // Both are non-epsilons. + return FilterState(0); + } + } + + void FilterFinal(Weight *, Weight *) const {} + + Matcher1 *GetMatcher1() { return matcher1_.get(); } + + Matcher2 *GetMatcher2() { return matcher2_.get(); } + + uint64 Properties(uint64 props) const { return props; } + + private: + std::unique_ptr matcher1_; + std::unique_ptr matcher2_; + const FST1 &fst1_; + const FST2 &fst2_; + StateId s1_; // Current fst1_ state. + StateId s2_; // Current fst2_ state. + FilterState fs_; // Current filter state ID. + bool alleps1_; // Only epsilson (and non-final) leaving s1? + bool alleps2_; // Only epsilons (and non-final) leaving s2? + bool noeps1_; // No epsilons leaving s1? + bool noeps2_; // No epsilons leaving s2? +}; + +// This filter works with the MultiEpsMatcher to determine if multi-epsilons are +// preserved in the composition output (rather than rewritten as 0) and +// ensures correct properties. +template +class MultiEpsFilter { + public: + using Matcher1 = typename Filter::Matcher1; + using Matcher2 = typename Filter::Matcher2; + using FST1 = typename Filter::FST1; + using FST2 = typename Filter::FST2; + using FilterState = typename Filter::FilterState; + + using Arc = typename Filter::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + MultiEpsFilter(const FST1 &fst1, const FST2 &fst2, + Matcher1 *matcher1 = nullptr, Matcher2 *matcher2 = nullptr, + bool keep_multi_eps = false) + : filter_(fst1, fst2, matcher1, matcher2), + keep_multi_eps_(keep_multi_eps) {} + + MultiEpsFilter(const MultiEpsFilter &filter, bool safe = false) + : filter_(filter.filter_, safe), + keep_multi_eps_(filter.keep_multi_eps_) {} + + FilterState Start() const { return filter_.Start(); } + + void SetState(StateId s1, StateId s2, const FilterState &fs) { + return filter_.SetState(s1, s2, fs); + } + + FilterState FilterArc(Arc *arc1, Arc *arc2) const { + const auto fs = filter_.FilterArc(arc1, arc2); + if (keep_multi_eps_) { + if (arc1->olabel == kNoLabel) arc1->ilabel = arc2->ilabel; + if (arc2->ilabel == kNoLabel) arc2->olabel = arc1->olabel; + } + return fs; + } + + void FilterFinal(Weight *w1, Weight *w2) const { + return filter_.FilterFinal(w1, w2); + } + + Matcher1 *GetMatcher1() { return filter_.GetMatcher1(); } + + Matcher2 *GetMatcher2() { return filter_.GetMatcher2(); } + + uint64 Properties(uint64 iprops) const { + const auto oprops = filter_.Properties(iprops); + return oprops & kILabelInvariantProperties & kOLabelInvariantProperties; + } + + private: + Filter filter_; + bool keep_multi_eps_; +}; + +} // namespace fst + +#endif // FST_COMPOSE_FILTER_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/compose.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/compose.h new file mode 100644 index 0000000000..0303409110 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/compose.h @@ -0,0 +1,1026 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Class to compute the composition of two FSTs. + +#ifndef FST_COMPOSE_H_ +#define FST_COMPOSE_H_ + +#include + +#include + +#include +#include +#include // For optional argument declarations +#include +#include +#include +#include + + +namespace fst { + +// Delayed composition options templated on the arc type, the matcher, +// the composition filter, and the composition state table. By +// default, the matchers, filter, and state table are constructed by +// composition. If set below, the user can instead pass in these +// objects; in that case, ComposeFst takes their ownership. This +// version controls composition implemented between generic Fst +// types and a shared matcher type M for Fst. This should be +// adequate for most applications, giving a reasonable tradeoff +// between efficiency and code sharing (but see ComposeFstImplOptions). +template >, + class Filter = SequenceComposeFilter, + class StateTable = + GenericComposeStateTable> +struct ComposeFstOptions : public CacheOptions { + M *matcher1; // FST1 matcher. + M *matcher2; // FST2 matcher. + Filter *filter; // Composition filter. + StateTable *state_table; // Composition state table. + + explicit ComposeFstOptions(const CacheOptions &opts = CacheOptions(), + M *matcher1 = nullptr, M *matcher2 = nullptr, + Filter *filter = nullptr, + StateTable *state_table = nullptr) + : CacheOptions(opts), + matcher1(matcher1), + matcher2(matcher2), + filter(filter), + state_table(state_table) {} +}; + +// Forward declaration of ComposeFstMatcher. +template +class ComposeFstMatcher; + +// Delayed composition options templated on the two matcher types, the +// composition filter, the composition state table and the cache store. By +// default, the matchers, filter, state table and cache store are constructed +// by composition. If set below, the user can instead pass in these objects; in +// that case, ComposeFst takes their ownership. This version controls +// composition implemented using arbitrary matchers (of the same arc type but +// otherwise arbitrary FST type). The user must ensure the matchers are +// compatible. These options permit the most efficient use, but shares the +// least code. This is for advanced use only in the most demanding or +// specialized applications that can benefit from it; otherwise, prefer +// ComposeFstOptions). +template , + class StateTable = GenericComposeStateTable< + typename M1::Arc, typename Filter::FilterState>, + class CacheStore = DefaultCacheStore> +struct ComposeFstImplOptions : public CacheImplOptions { + M1 *matcher1; // FST1 matcher (see matcher.h).... + M2 *matcher2; // FST2 matcher. + Filter *filter; // Composition filter (see compose-filter.h). + StateTable + *state_table; // Composition state table (see compose-state-table.h). + bool own_state_table; // ComposeFstImpl takes ownership of 'state_table'? + bool allow_noncommute; // Allow non-commutative weights + + explicit ComposeFstImplOptions(const CacheOptions &opts, + M1 *matcher1 = nullptr, M2 *matcher2 = nullptr, + Filter *filter = nullptr, + StateTable *state_table = nullptr) + : CacheImplOptions(opts), + matcher1(matcher1), + matcher2(matcher2), + filter(filter), + state_table(state_table), + own_state_table(true), + allow_noncommute(false) {} + + explicit ComposeFstImplOptions(const CacheImplOptions &opts, + M1 *matcher1 = nullptr, M2 *matcher2 = nullptr, + Filter *filter = nullptr, + StateTable *state_table = nullptr) + : CacheImplOptions(opts), + matcher1(matcher1), + matcher2(matcher2), + filter(filter), + state_table(state_table), + own_state_table(true), + allow_noncommute(false) {} + + ComposeFstImplOptions() + : matcher1(nullptr), + matcher2(nullptr), + filter(nullptr), + state_table(nullptr), + own_state_table(true), + allow_noncommute(false) {} +}; + +namespace internal { + +// Implementation of delayed composition. This base class is common to the +// variants with different matchers, composition filters and state tables. +template , + class F = ComposeFst> +class ComposeFstImplBase + : public CacheBaseImpl { + public: + using FST = F; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using State = typename CacheStore::State; + using CacheImpl = CacheBaseImpl; + + using FstImpl::SetType; + using FstImpl::SetProperties; + using FstImpl::Properties; + using FstImpl::SetInputSymbols; + using FstImpl::SetOutputSymbols; + + using CacheImpl::HasStart; + using CacheImpl::HasFinal; + using CacheImpl::HasArcs; + using CacheImpl::SetFinal; + using CacheImpl::SetStart; + + ComposeFstImplBase(const CacheImplOptions &opts) + : CacheImpl(opts) {} + + ComposeFstImplBase(const CacheOptions &opts) : CacheImpl(opts) {} + + ComposeFstImplBase(const ComposeFstImplBase &impl) : CacheImpl(impl, true) { + SetType(impl.Type()); + SetProperties(impl.Properties(), kCopyProperties); + SetInputSymbols(impl.InputSymbols()); + SetOutputSymbols(impl.OutputSymbols()); + } + + virtual ComposeFstImplBase *Copy() const = 0; + + ~ComposeFstImplBase() override {} + + StateId Start() { + if (!HasStart()) { + const auto start = ComputeStart(); + if (start != kNoStateId) SetStart(start); + } + return CacheImpl::Start(); + } + + Weight Final(StateId s) { + if (!HasFinal(s)) SetFinal(s, ComputeFinal(s)); + return CacheImpl::Final(s); + } + + virtual void Expand(StateId s) = 0; + + size_t NumArcs(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumArcs(s); + } + + size_t NumInputEpsilons(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumInputEpsilons(s); + } + + size_t NumOutputEpsilons(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumOutputEpsilons(s); + } + + void InitArcIterator(StateId s, ArcIteratorData *data) { + if (!HasArcs(s)) Expand(s); + CacheImpl::InitArcIterator(s, data); + } + + virtual MatcherBase *InitMatcher(const F &fst, + MatchType match_type) const { + // Use the default matcher if no override is provided. + return nullptr; + } + + protected: + virtual StateId ComputeStart() = 0; + virtual Weight ComputeFinal(StateId s) = 0; +}; + +// Implementation of delayed composition templated on the matchers (see +// matcher.h), composition filter (see compose-filter.h) and the composition +// state table (see compose-state-table.h). +template +class ComposeFstImpl + : public ComposeFstImplBase { + public: + using Matcher1 = typename Filter::Matcher1; + using Matcher2 = typename Filter::Matcher2; + + using FST1 = typename Matcher1::FST; + using FST2 = typename Matcher2::FST; + + using Arc = typename CacheStore::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using FilterState = typename Filter::FilterState; + using State = typename CacheStore::State; + + using CacheImpl = CacheBaseImpl; + + using StateTuple = typename StateTable::StateTuple; + + friend class ComposeFstMatcher; + + using FstImpl::SetInputSymbols; + using FstImpl::SetOutputSymbols; + using FstImpl::SetType; + using FstImpl::SetProperties; + + template + ComposeFstImpl(const FST1 &fst1, const FST2 &fst2, + const ComposeFstImplOptions &opts); + + ComposeFstImpl(const ComposeFstImpl &impl) + : ComposeFstImplBase(impl), + filter_(new Filter(*impl.filter_, true)), + matcher1_(filter_->GetMatcher1()), + matcher2_(filter_->GetMatcher2()), + fst1_(matcher1_->GetFst()), + fst2_(matcher2_->GetFst()), + state_table_(new StateTable(*impl.state_table_)), + own_state_table_(true), + match_type_(impl.match_type_) {} + + ~ComposeFstImpl() override { + if (own_state_table_) delete state_table_; + } + + ComposeFstImpl *Copy() const override { return new ComposeFstImpl(*this); } + + uint64 Properties() const override { return Properties(kFstProperties); } + + // Sets error if found, and returns other FST impl properties. + uint64 Properties(uint64 mask) const override { + if ((mask & kError) && + (fst1_.Properties(kError, false) || fst2_.Properties(kError, false) || + (matcher1_->Properties(0) & kError) || + (matcher2_->Properties(0) & kError) | + (filter_->Properties(0) & kError) || + state_table_->Error())) { + SetProperties(kError, kError); + } + return FstImpl::Properties(mask); + } + + // Arranges it so that the first arg to OrderedExpand is the Fst + // that will be matched on. + void Expand(StateId s) override { + const auto &tuple = state_table_->Tuple(s); + const auto s1 = tuple.StateId1(); + const auto s2 = tuple.StateId2(); + filter_->SetState(s1, s2, tuple.GetFilterState()); + if (MatchInput(s1, s2)) { + OrderedExpand(s, fst2_, s2, fst1_, s1, matcher2_, true); + } else { + OrderedExpand(s, fst1_, s1, fst2_, s2, matcher1_, false); + } + } + + const FST1 &GetFst1() const { return fst1_; } + + const FST2 &GetFst2() const { return fst2_; } + + const Matcher1 *GetMatcher1() const { return matcher1_; } + + Matcher1 *GetMatcher1() { return matcher1_; } + + const Matcher2 *GetMatcher2() const { return matcher2_; } + + Matcher2 *GetMatcher2() { return matcher2_; } + + const Filter *GetFilter() const { return filter_.get(); } + + Filter *GetFilter() { return filter_.get(); } + + const StateTable *GetStateTable() const { return state_table_; } + + StateTable *GetStateTable() { return state_table_; } + + MatcherBase *InitMatcher(const ComposeFst &fst, + MatchType match_type) const override { + const auto test_props = match_type == MATCH_INPUT + ? kFstProperties & ~kILabelInvariantProperties + : kFstProperties & ~kOLabelInvariantProperties; + // If both matchers support 'match_type' and we have a guarantee that a + // call to 'filter_->FilterArc(arc1, arc2)' will not modify the ilabel of + // arc1 when MATCH_INPUT or the olabel or arc2 when MATCH_OUTPUT, then + // ComposeFstMatcher can be used. + if ((matcher1_->Type(false) == match_type) && + (matcher2_->Type(false) == match_type) && + (filter_->Properties(test_props) == test_props)) { + return new ComposeFstMatcher< + CacheStore, Filter, StateTable>(&fst, match_type); + } + return nullptr; + } + + private: + // This does that actual matching of labels in the composition. The + // arguments are ordered so matching is called on state 'sa' of + // 'fsta' for each arc leaving state 'sb' of 'fstb'. The 'match_input' arg + // determines whether the input or output label of arcs at 'sb' is + // the one to match on. + template + void OrderedExpand(StateId s, const Fst &, StateId sa, const FST &fstb, + StateId sb, Matcher *matchera, bool match_input) { + matchera->SetState(sa); + // First processes non-consuming symbols (e.g., epsilons) on FSTA. + const Arc loop(match_input ? 0 : kNoLabel, match_input ? kNoLabel : 0, + Weight::One(), sb); + MatchArc(s, matchera, loop, match_input); + // Then processes matches on FSTB. + for (ArcIterator iterb(fstb, sb); !iterb.Done(); iterb.Next()) { + MatchArc(s, matchera, iterb.Value(), match_input); + } + CacheImpl::SetArcs(s); + } + + // Matches a single transition from 'fstb' against 'fata' at 's'. + template + void MatchArc(StateId s, Matcher *matchera, const Arc &arc, + bool match_input) { + if (matchera->Find(match_input ? arc.olabel : arc.ilabel)) { + for (; !matchera->Done(); matchera->Next()) { + auto arca = matchera->Value(); + auto arcb = arc; + if (match_input) { + const auto &fs = filter_->FilterArc(&arcb, &arca); + if (fs != FilterState::NoState()) AddArc(s, arcb, arca, fs); + } else { + const auto &fs = filter_->FilterArc(&arca, &arcb); + if (fs != FilterState::NoState()) AddArc(s, arca, arcb, fs); + } + } + } + } + + // Add a matching transition at 's'. + void AddArc(StateId s, const Arc &arc1, const Arc &arc2, + const FilterState &f) { + const StateTuple tuple(arc1.nextstate, arc2.nextstate, f); + const Arc oarc(arc1.ilabel, arc2.olabel, Times(arc1.weight, arc2.weight), + state_table_->FindState(tuple)); + CacheImpl::PushArc(s, oarc); + } + + StateId ComputeStart() override { + const auto s1 = fst1_.Start(); + if (s1 == kNoStateId) return kNoStateId; + const auto s2 = fst2_.Start(); + if (s2 == kNoStateId) return kNoStateId; + const auto &fs = filter_->Start(); + const StateTuple tuple(s1, s2, fs); + return state_table_->FindState(tuple); + } + + Weight ComputeFinal(StateId s) override { + const auto &tuple = state_table_->Tuple(s); + const auto s1 = tuple.StateId1(); + auto final1 = matcher1_->Final(s1); + if (final1 == Weight::Zero()) return final1; + const auto s2 = tuple.StateId2(); + auto final2 = matcher2_->Final(s2); + if (final2 == Weight::Zero()) return final2; + filter_->SetState(s1, s2, tuple.GetFilterState()); + filter_->FilterFinal(&final1, &final2); + return Times(final1, final2); + } + + // Determines which side to match on per composition state. + bool MatchInput(StateId s1, StateId s2) { + switch (match_type_) { + case MATCH_INPUT: + return true; + case MATCH_OUTPUT: + return false; + default: // MATCH_BOTH + const auto priority1 = matcher1_->Priority(s1); + const auto priority2 = matcher2_->Priority(s2); + if (priority1 == kRequirePriority && priority2 == kRequirePriority) { + FSTERROR() << "ComposeFst: Both sides can't require match"; + SetProperties(kError, kError); + return true; + } + if (priority1 == kRequirePriority) return false; + if (priority2 == kRequirePriority) { + return true; + } + return priority1 <= priority2; + } + } + + // Identifies and verifies the capabilities of the matcher to be used for + // composition. + void SetMatchType(); + + std::unique_ptr filter_; + Matcher1 *matcher1_; // Borrowed reference. + Matcher2 *matcher2_; // Borrowed reference. + const FST1 &fst1_; + const FST2 &fst2_; + StateTable *state_table_; + bool own_state_table_; + + MatchType match_type_; +}; + +template +template +ComposeFstImpl::ComposeFstImpl( + const FST1 &fst1, const FST2 &fst2, + const ComposeFstImplOptions &opts) + : ComposeFstImplBase(opts), + filter_(opts.filter + ? opts.filter + : new Filter(fst1, fst2, opts.matcher1, opts.matcher2)), + matcher1_(filter_->GetMatcher1()), + matcher2_(filter_->GetMatcher2()), + fst1_(matcher1_->GetFst()), + fst2_(matcher2_->GetFst()), + state_table_(opts.state_table ? opts.state_table + : new StateTable(fst1_, fst2_)), + own_state_table_(opts.state_table ? opts.own_state_table : true) { + SetType("compose"); + if (!CompatSymbols(fst2.InputSymbols(), fst1.OutputSymbols())) { + FSTERROR() << "ComposeFst: Output symbol table of 1st argument " + << "does not match input symbol table of 2nd argument"; + SetProperties(kError, kError); + } + SetInputSymbols(fst1_.InputSymbols()); + SetOutputSymbols(fst2_.OutputSymbols()); + SetMatchType(); + VLOG(2) << "ComposeFstImpl: Match type: " << match_type_; + if (match_type_ == MATCH_NONE) SetProperties(kError, kError); + const auto fprops1 = fst1.Properties(kFstProperties, false); + const auto fprops2 = fst2.Properties(kFstProperties, false); + const auto mprops1 = matcher1_->Properties(fprops1); + const auto mprops2 = matcher2_->Properties(fprops2); + const auto cprops = ComposeProperties(mprops1, mprops2); + SetProperties(filter_->Properties(cprops), kCopyProperties); + if (state_table_->Error()) SetProperties(kError, kError); +} + +template +void ComposeFstImpl::SetMatchType() { + // Ensures any required matching is possible and known. + if ((matcher1_->Flags() & kRequireMatch) && + matcher1_->Type(true) != MATCH_OUTPUT) { + FSTERROR() << "ComposeFst: 1st argument cannot perform required matching " + << "(sort?)."; + match_type_ = MATCH_NONE; + return; + } + if ((matcher2_->Flags() & kRequireMatch) && + matcher2_->Type(true) != MATCH_INPUT) { + FSTERROR() << "ComposeFst: 2nd argument cannot perform required matching " + << "(sort?)."; + match_type_ = MATCH_NONE; + return; + } + // Finds which sides to match on (favoring minimal testing of capabilities). + const auto type1 = matcher1_->Type(false); + const auto type2 = matcher2_->Type(false); + if (type1 == MATCH_OUTPUT && type2 == MATCH_INPUT) { + match_type_ = MATCH_BOTH; + } else if (type1 == MATCH_OUTPUT) { + match_type_ = MATCH_OUTPUT; + } else if (type2 == MATCH_INPUT) { + match_type_ = MATCH_INPUT; + } else if (matcher1_->Type(true) == MATCH_OUTPUT) { + match_type_ = MATCH_OUTPUT; + } else if (matcher2_->Type(true) == MATCH_INPUT) { + match_type_ = MATCH_INPUT; + } else { + FSTERROR() << "ComposeFst: 1st argument cannot match on output labels " + << "and 2nd argument cannot match on input labels (sort?)."; + match_type_ = MATCH_NONE; + } +} + +} // namespace internal + +// Computes the composition of two transducers. This version is a delayed FST. +// If FST1 transduces string x to y with weight a and FST2 transduces y to z +// with weight b, then their composition transduces string x to z with weight +// Times(x, z). +// +// The output labels of the first transducer or the input labels of the second +// transducer must be sorted (with the default matcher). The weights need to +// form a commutative semiring (valid for TropicalWeight and LogWeight). +// +// Complexity: +// +// Assuming the first FST is unsorted and the second is sorted, +// +// Time: O(v1 v2 d1 (log d2 + m2)), +// Space: O(v1 v2) +// +// where vi = # of states visited, di = maximum out-degree, and mi the +// maximum multiplicity of the states visited, for the ith FST. Constant time +// and space to visit an input state or arc is assumed and exclusive of caching. +// +// Caveats: +// - ComposeFst does not trim its output (since it is a delayed operation). +// - The efficiency of composition can be strongly affected by several factors: +// - the choice of which transducer is sorted - prefer sorting the FST +// that has the greater average out-degree. +// - the amount of non-determinism +// - the presence and location of epsilon transitions - avoid epsilon +// transitions on the output side of the first transducer or +// the input side of the second transducer or prefer placing +// them later in a path since they delay matching and can +// introduce non-coaccessible states and transitions. +// +// This class attaches interface to implementation and handles reference +// counting, delegating most methods to ImplToFst. The CacheStore specifies the +// cache store (default declared in fst-decl.h). +template */> +class ComposeFst + : public ImplToFst> { + public: + using Arc = A; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using Store = CacheStore; + using State = typename CacheStore::State; + + using Impl = internal::ComposeFstImplBase; + + friend class ArcIterator>; + friend class StateIterator>; + template friend class ComposeFstMatcher; + + // Compose specifying only caching options. + ComposeFst(const Fst &fst1, const Fst &fst2, + const CacheOptions &opts = CacheOptions()) + : ImplToFst(CreateBase(fst1, fst2, opts)) {} + + // Compose specifying one shared matcher type M. Requires that the input FSTs + // and matcher FST types be Fst. Recommended for best code-sharing and + // matcher compatiblity. + template + ComposeFst(const Fst &fst1, const Fst &fst2, + const ComposeFstOptions &opts) + : ImplToFst(CreateBase1(fst1, fst2, opts)) {} + + // Compose specifying two matcher types Matcher1 and Matcher2. Requires input + // FST (of the same Arc type, but o.w. arbitrary) match the corresponding + // matcher FST types). Recommended only for advanced use in demanding or + // specialized applications due to potential code bloat and matcher + // incompatibilities. + template + ComposeFst(const typename Matcher1::FST &fst1, + const typename Matcher2::FST &fst2, + const ComposeFstImplOptions &opts) + : ImplToFst(CreateBase2(fst1, fst2, opts)) {} + + // See Fst<>::Copy() for doc. + ComposeFst(const ComposeFst &fst, bool safe = false) + : ImplToFst(safe ? std::shared_ptr(fst.GetImpl()->Copy()) + : fst.GetSharedImpl()) {} + + // Get a copy of this ComposeFst. See Fst<>::Copy() for further doc. + ComposeFst *Copy(bool safe = false) const override { + return new ComposeFst(*this, safe); + } + + inline void InitStateIterator(StateIteratorData *data) const override; + + void InitArcIterator(StateId s, ArcIteratorData *data) const override { + GetMutableImpl()->InitArcIterator(s, data); + } + + MatcherBase *InitMatcher(MatchType match_type) const override { + return GetImpl()->InitMatcher(*this, match_type); + } + + protected: + using ImplToFst::GetImpl; + using ImplToFst::GetMutableImpl; + + explicit ComposeFst(std::shared_ptr impl) : ImplToFst(impl) {} + + // Create compose implementation specifying two matcher types. + template + static std::shared_ptr CreateBase2( + const typename Matcher1::FST &fst1, const typename Matcher2::FST &fst2, + const ComposeFstImplOptions &opts) { + auto impl = std::make_shared< + internal::ComposeFstImpl>(fst1, fst2, + opts); + if (!(Weight::Properties() & kCommutative) && !opts.allow_noncommute) { + const auto props1 = fst1.Properties(kUnweighted, true); + const auto props2 = fst2.Properties(kUnweighted, true); + if (!(props1 & kUnweighted) && !(props2 & kUnweighted)) { + FSTERROR() << "ComposeFst: Weights must be a commutative semiring: " + << Weight::Type(); + impl->SetProperties(kError, kError); + } + } + return impl; + } + + // Create compose implementation specifying one matcher type; requires that + // input and matcher FST types be Fst. + template + static std::shared_ptr CreateBase1( + const Fst &fst1, const Fst &fst2, + const ComposeFstOptions &opts) { + ComposeFstImplOptions + nopts(opts, opts.matcher1, opts.matcher2, opts.filter, + opts.state_table); + return CreateBase2(fst1, fst2, nopts); + } + + // Create compose implementation specifying no matcher type. + static std::shared_ptr CreateBase(const Fst &fst1, + const Fst &fst2, + const CacheOptions &opts) { + switch (LookAheadMatchType(fst1, fst2)) { // Check for lookahead matchers + default: + case MATCH_NONE: { // Default composition (no look-ahead). + ComposeFstOptions nopts(opts); + return CreateBase1(fst1, fst2, nopts); + } + case MATCH_OUTPUT: { // Lookahead on fst1. + using M = typename DefaultLookAhead::FstMatcher; + using F = typename DefaultLookAhead::ComposeFilter; + ComposeFstOptions nopts(opts); + return CreateBase1(fst1, fst2, nopts); + } + case MATCH_INPUT: { // Lookahead on fst2 + using M = typename DefaultLookAhead::FstMatcher; + using F = typename DefaultLookAhead::ComposeFilter; + ComposeFstOptions nopts(opts); + return CreateBase1(fst1, fst2, nopts); + } + } + } + + private: + ComposeFst &operator=(const ComposeFst &fst) = delete; +}; + +// Specialization for ComposeFst. +template +class StateIterator> + : public CacheStateIterator> { + public: + explicit StateIterator(const ComposeFst &fst) + : CacheStateIterator>(fst, + fst.GetMutableImpl()) {} +}; + +// Specialization for ComposeFst. +template +class ArcIterator> + : public CacheArcIterator> { + public: + using StateId = typename Arc::StateId; + + ArcIterator(const ComposeFst &fst, StateId s) + : CacheArcIterator>(fst.GetMutableImpl(), s) { + if (!fst.GetImpl()->HasArcs(s)) fst.GetMutableImpl()->Expand(s); + } +}; + +template +inline void ComposeFst::InitStateIterator( + StateIteratorData *data) const { + data->base = new StateIterator>(*this); +} + +// Specialized matcher for ComposeFst. Supports MATCH_INPUT or MATCH_OUTPUT, +// iff the underlying matchers for the two FSTS being composed support +// MATCH_INPUT or MATCH_OUTPUT, respectively. +template +class ComposeFstMatcher : public MatcherBase { + public: + using Arc = typename CacheStore::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using Matcher1 = typename Filter::Matcher1; + using Matcher2 = typename Filter::Matcher2; + using FilterState = typename Filter::FilterState; + + using StateTuple = typename StateTable::StateTuple; + using Impl = internal::ComposeFstImpl; + + // The compose FST arg must match the filter and state table types. + // This makes a copy of the FST. + ComposeFstMatcher(const ComposeFst &fst, + MatchType match_type) + : owned_fst_(fst.Copy()), + fst_(*owned_fst_), + impl_(static_cast(fst_.GetImpl())), + s_(kNoStateId), + match_type_(match_type), + matcher1_(impl_->matcher1_->Copy()), + matcher2_(impl_->matcher2_->Copy()), + current_loop_(false), + loop_(kNoLabel, 0, Weight::One(), kNoStateId) { + if (match_type_ == MATCH_OUTPUT) std::swap(loop_.ilabel, loop_.olabel); + } + + // The compose FST arg must match the filter and state table types. + // This doesn't copy the FST (although it may copy components). + ComposeFstMatcher(const ComposeFst *fst, + MatchType match_type) + : fst_(*fst), + impl_(static_cast(fst_.GetImpl())), + s_(kNoStateId), + match_type_(match_type), + matcher1_(impl_->matcher1_->Copy()), + matcher2_(impl_->matcher2_->Copy()), + current_loop_(false), + loop_(kNoLabel, 0, Weight::One(), kNoStateId) { + if (match_type_ == MATCH_OUTPUT) std::swap(loop_.ilabel, loop_.olabel); + } + + // This makes a copy of the FST. + ComposeFstMatcher( + const ComposeFstMatcher &matcher, + bool safe = false) + : owned_fst_(matcher.fst_.Copy(safe)), + fst_(*owned_fst_), + impl_(static_cast(fst_.GetImpl())), + s_(kNoStateId), + match_type_(matcher.match_type_), + matcher1_(matcher.matcher1_->Copy(safe)), + matcher2_(matcher.matcher2_->Copy(safe)), + current_loop_(false), + loop_(kNoLabel, 0, Weight::One(), kNoStateId) { + if (match_type_ == MATCH_OUTPUT) std::swap(loop_.ilabel, loop_.olabel); + } + + ComposeFstMatcher *Copy( + bool safe = false) const override { + return new ComposeFstMatcher(*this, safe); + } + + MatchType Type(bool test) const override { + if ((matcher1_->Type(test) == MATCH_NONE) || + (matcher2_->Type(test) == MATCH_NONE)) { + return MATCH_NONE; + } + if (((matcher1_->Type(test) == MATCH_UNKNOWN) && + (matcher2_->Type(test) == MATCH_UNKNOWN)) || + ((matcher1_->Type(test) == MATCH_UNKNOWN) && + (matcher2_->Type(test) == match_type_)) || + ((matcher1_->Type(test) == match_type_) && + (matcher2_->Type(test) == MATCH_UNKNOWN))) { + return MATCH_UNKNOWN; + } + if ((matcher1_->Type(test) == match_type_) && + (matcher2_->Type(test) == match_type_)) { + return match_type_; + } + return MATCH_NONE; + } + + const Fst &GetFst() const override { return fst_; } + + uint64 Properties(uint64 inprops) const override { + return inprops; + } + + void SetState(StateId s) final { + if (s_ == s) return; + s_ = s; + const auto &tuple = impl_->state_table_->Tuple(s); + matcher1_->SetState(tuple.StateId1()); + matcher2_->SetState(tuple.StateId2()); + loop_.nextstate = s_; + } + + bool Find(Label label) final { + bool found = false; + current_loop_ = false; + if (label == 0) { + current_loop_ = true; + found = true; + } + if (match_type_ == MATCH_INPUT) { + found = found || FindLabel(label, matcher1_.get(), matcher2_.get()); + } else { // match_type_ == MATCH_OUTPUT + found = found || FindLabel(label, matcher2_.get(), matcher1_.get()); + } + return found; + } + + bool Done() const final { + return !current_loop_ && matcher1_->Done() && matcher2_->Done(); + } + + const Arc &Value() const final { return current_loop_ ? loop_ : arc_; } + + void Next() final { + if (current_loop_) { + current_loop_ = false; + } else if (match_type_ == MATCH_INPUT) { + FindNext(matcher1_.get(), matcher2_.get()); + } else { // match_type_ == MATCH_OUTPUT + FindNext(matcher2_.get(), matcher1_.get()); + } + } + + ssize_t Priority(StateId s) final { return fst_.NumArcs(s); } + + private: + // Processes a match with the filter and creates resulting arc. + bool MatchArc(StateId s, Arc arc1, + Arc arc2) { // FIXME(kbg): copy but not assignment. + const auto &fs = impl_->filter_->FilterArc(&arc1, &arc2); + if (fs == FilterState::NoState()) return false; + const StateTuple tuple(arc1.nextstate, arc2.nextstate, fs); + arc_.ilabel = arc1.ilabel; + arc_.olabel = arc2.olabel; + arc_.weight = Times(arc1.weight, arc2.weight); + arc_.nextstate = impl_->state_table_->FindState(tuple); + return true; + } + + // Finds the first match allowed by the filter. + template + bool FindLabel(Label label, MatcherA *matchera, MatcherB *matcherb) { + if (matchera->Find(label)) { + matcherb->Find(match_type_ == MATCH_INPUT ? matchera->Value().olabel + : matchera->Value().ilabel); + return FindNext(matchera, matcherb); + } + return false; + } + + // Finds the next match allowed by the filter, returning true iff such a + // match is found. + template + bool FindNext(MatcherA *matchera, MatcherB *matcherb) { + // State when entering this function: + // 'matchera' is pointed to a match x, y for label x, and a match for y was + // requested on 'matcherb'. + while (!matchera->Done() || !matcherb->Done()) { + if (matcherb->Done()) { + // If no more matches for y on 'matcherb', moves forward on 'matchera' + // until a match x, y' is found such that there is a match for y' on + // 'matcherb'. + matchera->Next(); + while (!matchera->Done() && + !matcherb->Find(match_type_ == MATCH_INPUT + ? matchera->Value().olabel + : matchera->Value().ilabel)) { + matchera->Next(); + } + } + while (!matcherb->Done()) { + // 'matchera' is pointing to a match x, y' ('arca') and 'matcherb' is + // pointing to a match y', z' ('arcb'). If combining these two arcs is + // allowed by the filter (hence resulting in an arc x, z') return true. + // Position 'matcherb' on the next potential match for y' before + // returning. + const auto &arca = matchera->Value(); + const auto &arcb = matcherb->Value(); + // Position 'matcherb' on the next potential match for y'. + matcherb->Next(); + // Returns true If combining these two arcs is allowed by the filter + // (hence resulting in an arc x, z'); otherwise consider next match + // for y' on 'matcherb'. + if (MatchArc(s_, match_type_ == MATCH_INPUT ? arca : arcb, + match_type_ == MATCH_INPUT ? arcb : arca)) { + return true; + } + } + } + // Both 'matchera' and 'matcherb' are done, no more match to analyse. + return false; + } + + std::unique_ptr> owned_fst_; + const ComposeFst &fst_; + const Impl *impl_; + StateId s_; + MatchType match_type_; + std::unique_ptr matcher1_; + std::unique_ptr matcher2_; + bool current_loop_; + Arc loop_; + Arc arc_; +}; + +// Useful alias when using StdArc. +using StdComposeFst = ComposeFst; + +enum ComposeFilter { + AUTO_FILTER, + NULL_FILTER, + TRIVIAL_FILTER, + SEQUENCE_FILTER, + ALT_SEQUENCE_FILTER, + MATCH_FILTER +}; + +struct ComposeOptions { + bool connect; // Connect output? + ComposeFilter filter_type; // Pre-defined filter to use. + + explicit ComposeOptions(bool connect = true, + ComposeFilter filter_type = AUTO_FILTER) + : connect(connect), filter_type(filter_type) {} +}; + +// Computes the composition of two transducers. This version writes +// the composed FST into a MutableFst. If FST1 transduces string x to +// y with weight a and FST2 transduces y to z with weight b, then +// their composition transduces string x to z with weight +// Times(x, z). +// +// The output labels of the first transducer or the input labels of +// the second transducer must be sorted. The weights need to form a +// commutative semiring (valid for TropicalWeight and LogWeight). +// +// Complexity: +// +// Assuming the first FST is unsorted and the second is sorted: +// +// Time: O(V1 V2 D1 (log D2 + M2)), +// Space: O(V1 V2 D1 M2) +// +// where Vi = # of states, Di = maximum out-degree, and Mi is the maximum +// multiplicity, for the ith FST. +// +// Caveats: +// +// - Compose trims its output. +// - The efficiency of composition can be strongly affected by several factors: +// - the choice of which transducer is sorted - prefer sorting the FST +// that has the greater average out-degree. +// - the amount of non-determinism +// - the presence and location of epsilon transitions - avoid epsilon +// transitions on the output side of the first transducer or +// the input side of the second transducer or prefer placing +// them later in a path since they delay matching and can +// introduce non-coaccessible states and transitions. +template +void Compose(const Fst &ifst1, const Fst &ifst2, + MutableFst *ofst, + const ComposeOptions &opts = ComposeOptions()) { + using M = Matcher>; + // In each case, we cache only the last state for fastest copy. + switch (opts.filter_type) { + case AUTO_FILTER: { + CacheOptions nopts; + nopts.gc_limit = 0; + *ofst = ComposeFst(ifst1, ifst2, nopts); + break; + } + case NULL_FILTER: { + ComposeFstOptions> copts; + copts.gc_limit = 0; + *ofst = ComposeFst(ifst1, ifst2, copts); + break; + } + case SEQUENCE_FILTER: { + ComposeFstOptions> copts; + copts.gc_limit = 0; + *ofst = ComposeFst(ifst1, ifst2, copts); + break; + } + case ALT_SEQUENCE_FILTER: { + ComposeFstOptions> copts; + copts.gc_limit = 0; + *ofst = ComposeFst(ifst1, ifst2, copts); + break; + } + case MATCH_FILTER: { + ComposeFstOptions> copts; + copts.gc_limit = 0; + *ofst = ComposeFst(ifst1, ifst2, copts); + break; + } + case TRIVIAL_FILTER: { + ComposeFstOptions> copts; + copts.gc_limit = 0; + *ofst = ComposeFst(ifst1, ifst2, copts); + break; + } + } + if (opts.connect) Connect(ofst); +} + +} // namespace fst + +#endif // FST_COMPOSE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/concat.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/concat.h new file mode 100644 index 0000000000..8bf6e3e5df --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/concat.h @@ -0,0 +1,223 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Functions and classes to compute the concatenation of two FSTs. + +#ifndef FST_CONCAT_H_ +#define FST_CONCAT_H_ + +#include +#include + +#include +#include + + +namespace fst { + +// Computes the concatenation (product) of two FSTs. If FST1 transduces string +// x to y with weight a and FST2 transduces string w to v with weight b, then +// their concatenation transduces string xw to yv with weight Times(a, b). +// +// This version modifies its MutableFst argument (in first position). +// +// Complexity: +// +// Time: O(V1 + V2 + E2) +// Space: O(V1 + V2 + E2) +// +// where Vi is the number of states, and Ei is the number of arcs, of the ith +// FST. +template +void Concat(MutableFst *fst1, const Fst &fst2) { + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + // Checks that the symbol table are compatible. + if (!CompatSymbols(fst1->InputSymbols(), fst2.InputSymbols()) || + !CompatSymbols(fst1->OutputSymbols(), fst2.OutputSymbols())) { + FSTERROR() << "Concat: Input/output symbol tables of 1st argument " + << "does not match input/output symbol tables of 2nd argument"; + fst1->SetProperties(kError, kError); + return; + } + const auto props1 = fst1->Properties(kFstProperties, false); + const auto props2 = fst2.Properties(kFstProperties, false); + const auto start1 = fst1->Start(); + if (start1 == kNoStateId) { + if (props2 & kError) fst1->SetProperties(kError, kError); + return; + } + const auto numstates1 = fst1->NumStates(); + if (fst2.Properties(kExpanded, false)) { + fst1->ReserveStates(numstates1 + CountStates(fst2)); + } + for (StateIterator> siter2(fst2); !siter2.Done(); siter2.Next()) { + const auto s1 = fst1->AddState(); + const auto s2 = siter2.Value(); + fst1->SetFinal(s1, fst2.Final(s2)); + fst1->ReserveArcs(s1, fst2.NumArcs(s2)); + for (ArcIterator> aiter(fst2, s2); !aiter.Done(); aiter.Next()) { + auto arc = aiter.Value(); + arc.nextstate += numstates1; + fst1->AddArc(s1, arc); + } + } + const auto start2 = fst2.Start(); + for (StateId s1 = 0; s1 < numstates1; ++s1) { + const auto weight = fst1->Final(s1); + if (weight != Weight::Zero()) { + fst1->SetFinal(s1, Weight::Zero()); + if (start2 != kNoStateId) { + fst1->AddArc(s1, Arc(0, 0, weight, start2 + numstates1)); + } + } + } + if (start2 != kNoStateId) { + fst1->SetProperties(ConcatProperties(props1, props2), kFstProperties); + } +} + +// Computes the concatentation of two FSTs. This version modifies its +// MutableFst argument (in second position). +// +// Complexity: +// +// Time: O(V1 + E1) +// Space: O(V1 + E1) +// +// where Vi is the number of states, and Ei is the number of arcs, of the ith +// FST. +template +void Concat(const Fst &fst1, MutableFst *fst2) { + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + // Checks that the symbol table are compatible. + if (!CompatSymbols(fst1.InputSymbols(), fst2->InputSymbols()) || + !CompatSymbols(fst1.OutputSymbols(), fst2->OutputSymbols())) { + FSTERROR() << "Concat: Input/output symbol tables of 1st argument " + << "does not match input/output symbol tables of 2nd argument"; + fst2->SetProperties(kError, kError); + return; + } + const auto props1 = fst1.Properties(kFstProperties, false); + const auto props2 = fst2->Properties(kFstProperties, false); + const auto start2 = fst2->Start(); + if (start2 == kNoStateId) { + if (props1 & kError) fst2->SetProperties(kError, kError); + return; + } + const auto numstates2 = fst2->NumStates(); + if (fst1.Properties(kExpanded, false)) { + fst2->ReserveStates(numstates2 + CountStates(fst1)); + } + for (StateIterator> siter(fst1); !siter.Done(); siter.Next()) { + const auto s1 = siter.Value(); + const auto s2 = fst2->AddState(); + const auto weight = fst1.Final(s1); + if (weight != Weight::Zero()) { + fst2->ReserveArcs(s2, fst1.NumArcs(s1) + 1); + fst2->AddArc(s2, Arc(0, 0, weight, start2)); + } else { + fst2->ReserveArcs(s2, fst1.NumArcs(s1)); + } + for (ArcIterator> aiter(fst1, s1); !aiter.Done(); aiter.Next()) { + auto arc = aiter.Value(); + arc.nextstate += numstates2; + fst2->AddArc(s2, arc); + } + } + const auto start1 = fst1.Start(); + if (start1 != kNoStateId) { + fst2->SetStart(start1 + numstates2); + fst2->SetProperties(ConcatProperties(props1, props2), kFstProperties); + } else { + fst2->SetStart(fst2->AddState()); + } +} + +// Computes the concatentation of two FSTs. This version modifies its +// RationalFst input (in first position). +template +void Concat(RationalFst *fst1, const Fst &fst2) { + fst1->GetMutableImpl()->AddConcat(fst2, true); +} + +// Computes the concatentation of two FSTs. This version modifies its +// RationalFst input (in second position). +template +void Concat(const Fst &fst1, RationalFst *fst2) { + fst2->GetMutableImpl()->AddConcat(fst1, false); +} + +using ConcatFstOptions = RationalFstOptions; + +// Computes the concatenation (product) of two FSTs; this version is a delayed +// FST. If FST1 transduces string x to y with weight a and FST2 transduces +// string w to v with weight b, then their concatenation transduces string xw +// to yv with Times(a, b). +// +// Complexity: +// +// Time: O(v1 + e1 + v2 + e2), +// Space: O(v1 + v2) +// +// where vi is the number of states visited, and ei is the number of arcs +// visited, of the ith FST. Constant time and space to visit an input state or +// arc is assumed and exclusive of caching. +template +class ConcatFst : public RationalFst { + public: + using Arc = A; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + ConcatFst(const Fst &fst1, const Fst &fst2) { + GetMutableImpl()->InitConcat(fst1, fst2); + } + + ConcatFst(const Fst &fst1, const Fst &fst2, + const ConcatFstOptions &opts) + : RationalFst(opts) { + GetMutableImpl()->InitConcat(fst1, fst2); + } + + // See Fst<>::Copy() for doc. + ConcatFst(const ConcatFst &fst, bool safe = false) + : RationalFst(fst, safe) {} + + // Get a copy of this ConcatFst. See Fst<>::Copy() for further doc. + ConcatFst *Copy(bool safe = false) const override { + return new ConcatFst(*this, safe); + } + + private: + using ImplToFst>::GetImpl; + using ImplToFst>::GetMutableImpl; +}; + +// Specialization for ConcatFst. +template +class StateIterator> : public StateIterator> { + public: + explicit StateIterator(const ConcatFst &fst) + : StateIterator>(fst) {} +}; + +// Specialization for ConcatFst. +template +class ArcIterator> : public ArcIterator> { + public: + using StateId = typename Arc::StateId; + + ArcIterator(const ConcatFst &fst, StateId s) + : ArcIterator>(fst, s) {} +}; + +// Useful alias when using StdArc. +using StdConcatFst = ConcatFst; + +} // namespace fst + +#endif // FST_CONCAT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/config.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/config.h new file mode 100644 index 0000000000..046b49c8c3 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/config.h @@ -0,0 +1,12 @@ +/* src/include/fst/config.h. Generated from config.h.in by configure. */ +// OpenFst config file + +/* Define to 1 if you have the ICU library. */ +/* #undef HAVE_ICU */ + +/* Define to 1 if the system has the type `std::tr1::hash'. */ +#define HAVE_STD__TR1__HASH_LONG_LONG_UNSIGNED_ 1 + +/* Define to 1 if the system has the type `__gnu_cxx::slist'. */ +#define HAVE___GNU_CXX__SLIST_INT_ 1 diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/config.h.in b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/config.h.in new file mode 100644 index 0000000000..7815dfcdf8 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/config.h.in @@ -0,0 +1,11 @@ +// OpenFst config file + +/* Define to 1 if you have the ICU library. */ +#undef HAVE_ICU + +/* Define to 1 if the system has the type `std::tr1::hash'. */ +#define HAVE_STD__TR1__HASH_LONG_LONG_UNSIGNED_ 1 + +/* Define to 1 if the system has the type `__gnu_cxx::slist'. */ +#define HAVE___GNU_CXX__SLIST_INT_ 1 diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/connect.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/connect.h new file mode 100644 index 0000000000..8b1ddaf4ef --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/connect.h @@ -0,0 +1,314 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Classes and functions to remove unsuccessful paths from an FST. + +#ifndef FST_CONNECT_H_ +#define FST_CONNECT_H_ + +#include + +#include +#include +#include + + +namespace fst { + +// Finds and returns connected components. Use with Visit(). +template +class CcVisitor { + public: + using Weight = typename Arc::Weight; + using StateId = typename Arc::StateId; + + // cc[i]: connected component number for state i. + explicit CcVisitor(std::vector *cc) + : comps_(new UnionFind(0, kNoStateId)), cc_(cc), nstates_(0) {} + + // comps: connected components equiv classes. + explicit CcVisitor(UnionFind *comps) + : comps_(comps), cc_(nullptr), nstates_(0) {} + + ~CcVisitor() { + if (cc_) delete comps_; + } + + void InitVisit(const Fst &fst) {} + + bool InitState(StateId s, StateId root) { + ++nstates_; + if (comps_->FindSet(s) == kNoStateId) comps_->MakeSet(s); + return true; + } + + bool WhiteArc(StateId s, const Arc &arc) { + comps_->MakeSet(arc.nextstate); + comps_->Union(s, arc.nextstate); + return true; + } + + bool GreyArc(StateId s, const Arc &arc) { + comps_->Union(s, arc.nextstate); + return true; + } + + bool BlackArc(StateId s, const Arc &arc) { + comps_->Union(s, arc.nextstate); + return true; + } + + void FinishState(StateId s) {} + + void FinishVisit() { + if (cc_) GetCcVector(cc_); + } + + // Returns number of components. + // cc[i]: connected component number for state i. + int GetCcVector(std::vector *cc) { + cc->clear(); + cc->resize(nstates_, kNoStateId); + StateId ncomp = 0; + for (StateId s = 0; s < nstates_; ++s) { + const auto rep = comps_->FindSet(s); + auto &comp = (*cc)[rep]; + if (comp == kNoStateId) { + comp = ncomp; + ++ncomp; + } + (*cc)[s] = comp; + } + return ncomp; + } + + private: + UnionFind *comps_; // Components. + std::vector *cc_; // State's cc number. + StateId nstates_; // State count. +}; + +// Finds and returns strongly-connected components, accessible and +// coaccessible states and related properties. Uses Tarjan's single +// DFS SCC algorithm (see Aho, et al, "Design and Analysis of Computer +// Algorithms", 189pp). Use with DfsVisit(); +template +class SccVisitor { + public: + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + // scc[i]: strongly-connected component number for state i. + // SCC numbers will be in topological order for acyclic input. + // access[i]: accessibility of state i. + // coaccess[i]: coaccessibility of state i. + // Any of above can be NULL. + // props: related property bits (cyclicity, initial cyclicity, + // accessibility, coaccessibility) set/cleared (o.w. unchanged). + SccVisitor(std::vector *scc, std::vector *access, + std::vector *coaccess, uint64 *props) + : scc_(scc), access_(access), coaccess_(coaccess), props_(props) {} + explicit SccVisitor(uint64 *props) + : scc_(nullptr), access_(nullptr), coaccess_(nullptr), props_(props) {} + + void InitVisit(const Fst &fst); + + bool InitState(StateId s, StateId root); + + bool TreeArc(StateId s, const Arc &arc) { return true; } + + bool BackArc(StateId s, const Arc &arc) { + const auto t = arc.nextstate; + if ((*dfnumber_)[t] < (*lowlink_)[s]) (*lowlink_)[s] = (*dfnumber_)[t]; + if ((*coaccess_)[t]) (*coaccess_)[s] = true; + *props_ |= kCyclic; + *props_ &= ~kAcyclic; + if (t == start_) { + *props_ |= kInitialCyclic; + *props_ &= ~kInitialAcyclic; + } + return true; + } + + bool ForwardOrCrossArc(StateId s, const Arc &arc) { + const auto t = arc.nextstate; + if ((*dfnumber_)[t] < (*dfnumber_)[s] /* cross edge */ && (*onstack_)[t] && + (*dfnumber_)[t] < (*lowlink_)[s]) { + (*lowlink_)[s] = (*dfnumber_)[t]; + } + if ((*coaccess_)[t]) (*coaccess_)[s] = true; + return true; + } + + // Last argument always ignored, but required by the interface. + void FinishState(StateId state, StateId p, const Arc *); + + void FinishVisit() { + // Numbers SCCs in topological order when acyclic. + if (scc_) { + for (StateId s = 0; s < scc_->size(); ++s) { + (*scc_)[s] = nscc_ - 1 - (*scc_)[s]; + } + } + if (coaccess_internal_) delete coaccess_; + dfnumber_.reset(); + lowlink_.reset(); + onstack_.reset(); + scc_stack_.reset(); + } + + private: + std::vector *scc_; // State's scc number. + std::vector *access_; // State's accessibility. + std::vector *coaccess_; // State's coaccessibility. + uint64 *props_; + const Fst *fst_; + StateId start_; + StateId nstates_; // State count. + StateId nscc_; // SCC count. + bool coaccess_internal_; + std::unique_ptr> dfnumber_; // State discovery times. + std::unique_ptr> + lowlink_; // lowlink[state] == dfnumber[state] => SCC root + std::unique_ptr> onstack_; // Is a state on the SCC stack? + std::unique_ptr> + scc_stack_; // SCC stack, with random access. +}; + +template +inline void SccVisitor::InitVisit(const Fst &fst) { + if (scc_) scc_->clear(); + if (access_) access_->clear(); + if (coaccess_) { + coaccess_->clear(); + coaccess_internal_ = false; + } else { + coaccess_ = new std::vector; + coaccess_internal_ = true; + } + *props_ |= kAcyclic | kInitialAcyclic | kAccessible | kCoAccessible; + *props_ &= ~(kCyclic | kInitialCyclic | kNotAccessible | kNotCoAccessible); + fst_ = &fst; + start_ = fst.Start(); + nstates_ = 0; + nscc_ = 0; + dfnumber_.reset(new std::vector()); + lowlink_.reset(new std::vector()); + onstack_.reset(new std::vector()); + scc_stack_.reset(new std::vector()); +} + +template +inline bool SccVisitor::InitState(StateId s, StateId root) { + scc_stack_->push_back(s); + while (dfnumber_->size() <= s) { + if (scc_) scc_->push_back(-1); + if (access_) access_->push_back(false); + coaccess_->push_back(false); + dfnumber_->push_back(-1); + lowlink_->push_back(-1); + onstack_->push_back(false); + } + (*dfnumber_)[s] = nstates_; + (*lowlink_)[s] = nstates_; + (*onstack_)[s] = true; + if (root == start_) { + if (access_) (*access_)[s] = true; + } else { + if (access_) (*access_)[s] = false; + *props_ |= kNotAccessible; + *props_ &= ~kAccessible; + } + ++nstates_; + return true; +} + +template +inline void SccVisitor::FinishState(StateId s, StateId p, const Arc *) { + if (fst_->Final(s) != Weight::Zero()) (*coaccess_)[s] = true; + if ((*dfnumber_)[s] == (*lowlink_)[s]) { // Root of new SCC. + bool scc_coaccess = false; + auto i = scc_stack_->size(); + StateId t; + do { + t = (*scc_stack_)[--i]; + if ((*coaccess_)[t]) scc_coaccess = true; + } while (s != t); + do { + t = scc_stack_->back(); + if (scc_) (*scc_)[t] = nscc_; + if (scc_coaccess) (*coaccess_)[t] = true; + (*onstack_)[t] = false; + scc_stack_->pop_back(); + } while (s != t); + if (!scc_coaccess) { + *props_ |= kNotCoAccessible; + *props_ &= ~kCoAccessible; + } + ++nscc_; + } + if (p != kNoStateId) { + if ((*coaccess_)[s]) (*coaccess_)[p] = true; + if ((*lowlink_)[s] < (*lowlink_)[p]) (*lowlink_)[p] = (*lowlink_)[s]; + } +} + +// Trims an FST, removing states and arcs that are not on successful paths. +// This version modifies its input. +// +// Complexity: +// +// Time: O(V + E) +// Space: O(V + E) +// +// where V = # of states and E = # of arcs. +template +void Connect(MutableFst *fst) { + using StateId = typename Arc::StateId; + std::vector access; + std::vector coaccess; + uint64 props = 0; + SccVisitor scc_visitor(nullptr, &access, &coaccess, &props); + DfsVisit(*fst, &scc_visitor); + std::vector dstates; + for (StateId s = 0; s < access.size(); ++s) { + if (!access[s] || !coaccess[s]) dstates.push_back(s); + } + fst->DeleteStates(dstates); + fst->SetProperties(kAccessible | kCoAccessible, kAccessible | kCoAccessible); +} + +// Returns an acyclic FST where each SCC in the input FST has been condensed to +// a single state with transitions between SCCs retained and within SCCs +// dropped. Also populates 'scc' with a mapping from input to output states. +template +void Condense(const Fst &ifst, MutableFst *ofst, + std::vector *scc) { + using StateId = typename Arc::StateId; + ofst->DeleteStates(); + uint64 props = 0; + SccVisitor scc_visitor(scc, nullptr, nullptr, &props); + DfsVisit(ifst, &scc_visitor); + for (StateId s = 0; s < scc->size(); ++s) { + const auto c = (*scc)[s]; + while (c >= ofst->NumStates()) ofst->AddState(); + if (s == ifst.Start()) ofst->SetStart(c); + const auto weight = ifst.Final(s); + if (weight != Arc::Weight::Zero()) + ofst->SetFinal(c, Plus(ofst->Final(c), weight)); + for (ArcIterator> aiter(ifst, s); !aiter.Done(); aiter.Next()) { + auto arc = aiter.Value(); + const auto nextc = (*scc)[arc.nextstate]; + if (nextc != c) { + while (nextc >= ofst->NumStates()) ofst->AddState(); + arc.nextstate = nextc; + ofst->AddArc(c, arc); + } + } + } + ofst->SetProperties(kAcyclic | kInitialAcyclic, kAcyclic | kInitialAcyclic); +} + +} // namespace fst + +#endif // FST_CONNECT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/const-fst.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/const-fst.h new file mode 100644 index 0000000000..1a2cba6a1d --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/const-fst.h @@ -0,0 +1,488 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Simple concrete immutable FST whose states and arcs are each stored in +// single arrays. + +#ifndef FST_CONST_FST_H_ +#define FST_CONST_FST_H_ + +#include +#include +#include + +// Google-only... +// ...Google-only +#include + +#include +#include +#include +#include +#include + + +namespace fst { + +template +class ConstFst; + +template +void Cast(const F &, G *); + +namespace internal { + +// States and arcs each implemented by single arrays, templated on the +// Arc definition. Unsigned is used to represent indices into the arc array. +template +class ConstFstImpl : public FstImpl { + public: + using Arc = A; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using FstImpl::SetInputSymbols; + using FstImpl::SetOutputSymbols; + using FstImpl::SetType; + using FstImpl::SetProperties; + using FstImpl::Properties; + + ConstFstImpl() + : states_(nullptr), + arcs_(nullptr), + nstates_(0), + narcs_(0), + start_(kNoStateId) { + string type = "const"; + if (sizeof(Unsigned) != sizeof(uint32)) { + type += std::to_string(CHAR_BIT * sizeof(Unsigned)); + } + SetType(type); + SetProperties(kNullProperties | kStaticProperties); + } + + explicit ConstFstImpl(const Fst &fst); + + StateId Start() const { return start_; } + + Weight Final(StateId s) const { return states_[s].weight; } + + StateId NumStates() const { return nstates_; } + + size_t NumArcs(StateId s) const { return states_[s].narcs; } + + size_t NumInputEpsilons(StateId s) const { return states_[s].niepsilons; } + + size_t NumOutputEpsilons(StateId s) const { return states_[s].noepsilons; } + + static ConstFstImpl *Read(std::istream &strm, + const FstReadOptions &opts); + + const Arc *Arcs(StateId s) const { return arcs_ + states_[s].pos; } + + // Provide information needed for generic state iterator. + void InitStateIterator(StateIteratorData *data) const { + data->base = nullptr; + data->nstates = nstates_; + } + + // Provide information needed for the generic arc iterator. + void InitArcIterator(StateId s, ArcIteratorData *data) const { + data->base = nullptr; + data->arcs = arcs_ + states_[s].pos; + data->narcs = states_[s].narcs; + data->ref_count = nullptr; + } + + private: + // Used to find narcs_ and nstates_ in Write. + friend class ConstFst; + + // States implemented by array *states_ below, arcs by (single) *arcs_. + struct ConstState { + Weight weight; // Final weight. + Unsigned pos; // Start of state's arcs in *arcs_. + Unsigned narcs; // Number of arcs (per state). + Unsigned niepsilons; // Number of input epsilons. + Unsigned noepsilons; // Number of output epsilons. + + ConstState() : weight(Weight::Zero()) {} + }; + + // Properties always true of this FST class. + static constexpr uint64 kStaticProperties = kExpanded; + // Current unaligned file format version. The unaligned version was added and + // made the default since the aligned version does not work on pipes. + static constexpr int kFileVersion = 2; + // Current aligned file format version. + static constexpr int kAlignedFileVersion = 1; + // Minimum file format version supported. + static constexpr int kMinFileVersion = 1; + + std::unique_ptr states_region_; // Mapped file for states. + std::unique_ptr arcs_region_; // Mapped file for arcs. + ConstState *states_; // States representation. + Arc *arcs_; // Arcs representation. + StateId nstates_; // Number of states. + size_t narcs_; // Number of arcs. + StateId start_; // Initial state. + + ConstFstImpl(const ConstFstImpl &) = delete; + ConstFstImpl &operator=(const ConstFstImpl &) = delete; +}; + +template +constexpr uint64 ConstFstImpl::kStaticProperties; + +template +constexpr int ConstFstImpl::kFileVersion; + +template +constexpr int ConstFstImpl::kAlignedFileVersion; + +template +constexpr int ConstFstImpl::kMinFileVersion; + +template +ConstFstImpl::ConstFstImpl(const Fst &fst) + : nstates_(0), narcs_(0) { + string type = "const"; + if (sizeof(Unsigned) != sizeof(uint32)) { + type += std::to_string(CHAR_BIT * sizeof(Unsigned)); + } + SetType(type); + SetInputSymbols(fst.InputSymbols()); + SetOutputSymbols(fst.OutputSymbols()); + start_ = fst.Start(); + // Counts states and arcs. + for (StateIterator> siter(fst); !siter.Done(); siter.Next()) { + ++nstates_; + for (ArcIterator> aiter(fst, siter.Value()); !aiter.Done(); + aiter.Next()) { + ++narcs_; + } + } + states_region_.reset(MappedFile::Allocate(nstates_ * sizeof(*states_))); + arcs_region_.reset(MappedFile::Allocate(narcs_ * sizeof(*arcs_))); + states_ = reinterpret_cast(states_region_->mutable_data()); + arcs_ = reinterpret_cast(arcs_region_->mutable_data()); + size_t pos = 0; + for (StateId s = 0; s < nstates_; ++s) { + states_[s].weight = fst.Final(s); + states_[s].pos = pos; + states_[s].narcs = 0; + states_[s].niepsilons = 0; + states_[s].noepsilons = 0; + for (ArcIterator> aiter(fst, s); !aiter.Done(); aiter.Next()) { + const auto &arc = aiter.Value(); + ++states_[s].narcs; + if (arc.ilabel == 0) ++states_[s].niepsilons; + if (arc.olabel == 0) ++states_[s].noepsilons; + arcs_[pos] = arc; + ++pos; + } + } + const auto props = + fst.Properties(kMutable, false) + ? fst.Properties(kCopyProperties, true) + : CheckProperties( + fst, kCopyProperties & ~kWeightedCycles & ~kUnweightedCycles, + kCopyProperties); + SetProperties(props | kStaticProperties); +} + +template +ConstFstImpl *ConstFstImpl::Read( + std::istream &strm, const FstReadOptions &opts) { + using ConstState = typename ConstFstImpl::ConstState; + std::unique_ptr> impl( + new ConstFstImpl()); + FstHeader hdr; + if (!impl->ReadHeader(strm, opts, kMinFileVersion, &hdr)) return nullptr; + impl->start_ = hdr.Start(); + impl->nstates_ = hdr.NumStates(); + impl->narcs_ = hdr.NumArcs(); + // Ensures compatibility. + if (hdr.Version() == kAlignedFileVersion) { + hdr.SetFlags(hdr.GetFlags() | FstHeader::IS_ALIGNED); + } + if ((hdr.GetFlags() & FstHeader::IS_ALIGNED) && !AlignInput(strm)) { + LOG(ERROR) << "ConstFst::Read: Alignment failed: " << opts.source; + return nullptr; + } + size_t b = impl->nstates_ * sizeof(ConstState); + impl->states_region_.reset( + MappedFile::Map(&strm, opts.mode == FstReadOptions::MAP, opts.source, b)); + if (!strm || !impl->states_region_) { + LOG(ERROR) << "ConstFst::Read: Read failed: " << opts.source; + return nullptr; + } + impl->states_ = + reinterpret_cast(impl->states_region_->mutable_data()); + if ((hdr.GetFlags() & FstHeader::IS_ALIGNED) && !AlignInput(strm)) { + LOG(ERROR) << "ConstFst::Read: Alignment failed: " << opts.source; + return nullptr; + } + b = impl->narcs_ * sizeof(Arc); + impl->arcs_region_.reset( + MappedFile::Map(&strm, opts.mode == FstReadOptions::MAP, opts.source, b)); + if (!strm || !impl->arcs_region_) { + LOG(ERROR) << "ConstFst::Read: Read failed: " << opts.source; + return nullptr; + } + impl->arcs_ = reinterpret_cast(impl->arcs_region_->mutable_data()); + return impl.release(); +} + +} // namespace internal + +// Simple concrete immutable FST. This class attaches interface to +// implementation and handles reference counting, delegating most methods to +// ImplToExpandedFst. The unsigned type U is used to represent indices into the +// arc array (default declared in fst-decl.h). +template +class ConstFst : public ImplToExpandedFst> { + public: + using Arc = A; + using StateId = typename Arc::StateId; + + using Impl = internal::ConstFstImpl; + using ConstState = typename Impl::ConstState; + + friend class StateIterator>; + friend class ArcIterator>; + + template + void friend Cast(const F &, G *); + + ConstFst() : ImplToExpandedFst(std::make_shared()) {} + + explicit ConstFst(const Fst &fst) + : ImplToExpandedFst(std::make_shared(fst)) {} + + ConstFst(const ConstFst &fst, bool safe = false) + : ImplToExpandedFst(fst) {} + + // Gets a copy of this ConstFst. See Fst<>::Copy() for further doc. + ConstFst *Copy(bool safe = false) const override { + return new ConstFst(*this, safe); + } + + // Reads a ConstFst from an input stream, returning nullptr on error. + static ConstFst *Read(std::istream &strm, + const FstReadOptions &opts) { + auto *impl = Impl::Read(strm, opts); + return impl ? new ConstFst(std::shared_ptr(impl)) + : nullptr; + } + + // Read a ConstFst from a file; return nullptr on error; empty filename reads + // from standard input. + static ConstFst *Read(const string &filename) { + auto *impl = ImplToExpandedFst::Read(filename); + return impl ? new ConstFst(std::shared_ptr(impl)) + : nullptr; + } + + bool Write(std::ostream &strm, const FstWriteOptions &opts) const override { + return WriteFst(*this, strm, opts); + } + + bool Write(const string &filename) const override { + return Fst::WriteFile(filename); + } + + template + static bool WriteFst(const FST &fst, std::ostream &strm, + const FstWriteOptions &opts); + + void InitStateIterator(StateIteratorData *data) const override { + GetImpl()->InitStateIterator(data); + } + + void InitArcIterator(StateId s, ArcIteratorData *data) const override { + GetImpl()->InitArcIterator(s, data); + } + + private: + explicit ConstFst(std::shared_ptr impl) + : ImplToExpandedFst(impl) {} + + using ImplToFst>::GetImpl; + + // Uses overloading to extract the type of the argument. + static const Impl *GetImplIfConstFst(const ConstFst &const_fst) { + return const_fst.GetImpl(); + } + + // NB: this does not give privileged treatment to subtypes of ConstFst. + template + static Impl *GetImplIfConstFst(const FST &fst) { + return nullptr; + } + + ConstFst &operator=(const ConstFst &) = delete; +}; + +// Writes FST in Const format, potentially with a pass over the machine before +// writing to compute number of states and arcs. +template +template +bool ConstFst::WriteFst(const FST &fst, std::ostream &strm, + const FstWriteOptions &opts) { + const auto file_version = + opts.align ? internal::ConstFstImpl::kAlignedFileVersion + : internal::ConstFstImpl::kFileVersion; + size_t num_arcs = 0; // To silence -Wsometimes-uninitialized warnings. + size_t num_states = 0; // Ditto. + size_t start_offset = 0; + bool update_header = true; + if (const auto *impl = GetImplIfConstFst(fst)) { + num_arcs = impl->narcs_; + num_states = impl->nstates_; + update_header = false; + } else if (opts.stream_write || (start_offset = strm.tellp()) == -1) { + // precompute values needed for header when we cannot seek to rewrite it. + num_arcs = 0; + num_states = 0; + for (StateIterator siter(fst); !siter.Done(); siter.Next()) { + num_arcs += fst.NumArcs(siter.Value()); + ++num_states; + } + update_header = false; + } + FstHeader hdr; + hdr.SetStart(fst.Start()); + hdr.SetNumStates(num_states); + hdr.SetNumArcs(num_arcs); + string type = "const"; + if (sizeof(Unsigned) != sizeof(uint32)) { + type += std::to_string(CHAR_BIT * sizeof(Unsigned)); + } + const auto properties = + fst.Properties(kCopyProperties, true) | + internal::ConstFstImpl::kStaticProperties; + internal::FstImpl::WriteFstHeader(fst, strm, opts, file_version, type, + properties, &hdr); + if (opts.align && !AlignOutput(strm)) { + LOG(ERROR) << "Could not align file during write after header"; + return false; + } + size_t pos = 0; + size_t states = 0; + typename ConstFst::ConstState state; + for (StateIterator siter(fst); !siter.Done(); siter.Next()) { + const auto s = siter.Value(); + state.weight = fst.Final(s); + state.pos = pos; + state.narcs = fst.NumArcs(s); + state.niepsilons = fst.NumInputEpsilons(s); + state.noepsilons = fst.NumOutputEpsilons(s); + strm.write(reinterpret_cast(&state), sizeof(state)); + pos += state.narcs; + ++states; + } + hdr.SetNumStates(states); + hdr.SetNumArcs(pos); + if (opts.align && !AlignOutput(strm)) { + LOG(ERROR) << "Could not align file during write after writing states"; + } + for (StateIterator siter(fst); !siter.Done(); siter.Next()) { + for (ArcIterator aiter(fst, siter.Value()); !aiter.Done(); + aiter.Next()) { + const auto &arc = aiter.Value(); +// Google-only... +#ifdef MEMORY_SANITIZER + // arc may contain padding which has unspecified contents. Tell MSAN to + // not complain about it when writing it to a file. + ANNOTATE_MEMORY_IS_INITIALIZED(reinterpret_cast(&arc), + sizeof(arc)); +#endif + // ...Google-only + strm.write(reinterpret_cast(&arc), sizeof(arc)); + } + } + strm.flush(); + if (!strm) { + LOG(ERROR) << "ConstFst::WriteFst: write failed: " << opts.source; + return false; + } + if (update_header) { + return internal::FstImpl::UpdateFstHeader( + fst, strm, opts, file_version, type, properties, &hdr, start_offset); + } else { + if (hdr.NumStates() != num_states) { + LOG(ERROR) << "Inconsistent number of states observed during write"; + return false; + } + if (hdr.NumArcs() != num_arcs) { + LOG(ERROR) << "Inconsistent number of arcs observed during write"; + return false; + } + } + return true; +} + +// Specialization for ConstFst; see generic version in fst.h for sample usage +// (but use the ConstFst type instead). This version should inline. +template +class StateIterator> { + public: + using StateId = typename Arc::StateId; + + explicit StateIterator(const ConstFst &fst) + : nstates_(fst.GetImpl()->NumStates()), s_(0) {} + + bool Done() const { return s_ >= nstates_; } + + StateId Value() const { return s_; } + + void Next() { ++s_; } + + void Reset() { s_ = 0; } + + private: + const StateId nstates_; + StateId s_; +}; + +// Specialization for ConstFst; see generic version in fst.h for sample usage +// (but use the ConstFst type instead). This version should inline. +template +class ArcIterator> { + public: + using StateId = typename Arc::StateId; + + ArcIterator(const ConstFst &fst, StateId s) + : arcs_(fst.GetImpl()->Arcs(s)), + narcs_(fst.GetImpl()->NumArcs(s)), + i_(0) {} + + bool Done() const { return i_ >= narcs_; } + + const Arc &Value() const { return arcs_[i_]; } + + void Next() { ++i_; } + + size_t Position() const { return i_; } + + void Reset() { i_ = 0; } + + void Seek(size_t a) { i_ = a; } + + constexpr uint32 Flags() const { return kArcValueFlags; } + + void SetFlags(uint32, uint32) {} + + private: + const Arc *arcs_; + size_t narcs_; + size_t i_; +}; + +// A useful alias when using StdArc. +using StdConstFst = ConstFst; + +} // namespace fst + +#endif // FST_CONST_FST_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/determinize.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/determinize.h new file mode 100644 index 0000000000..6d446cd31b --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/determinize.h @@ -0,0 +1,1092 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Functions and classes to determinize an FST. + +#ifndef FST_DETERMINIZE_H_ +#define FST_DETERMINIZE_H_ + +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include + + +namespace fst { + +// Common divisors are used in determinization to compute transition weights. +// In the simplest case, it is the same as semiring Plus, but other choices +// permit more efficient determinization when the output contains strings. + +// The default common divisor uses the semiring Plus. +template +struct DefaultCommonDivisor { + public: + using Weight = W; + + Weight operator()(const Weight &w1, const Weight &w2) const { + return Plus(w1, w2); + } +}; + +// The label common divisor for a (left) string semiring selects a single +// letter common prefix or the empty string. This is used in the +// determinization of output strings so that at most a single letter will +// appear in the output of a transtion. +template +struct LabelCommonDivisor { + public: + using Weight = StringWeight; + + Weight operator()(const Weight &w1, const Weight &w2) const { + typename Weight::Iterator iter1(w1); + typename Weight::Iterator iter2(w2); + if (!(StringWeight::Properties() & kLeftSemiring)) { + FSTERROR() << "LabelCommonDivisor: Weight needs to be left semiring"; + return Weight::NoWeight(); + } else if (w1.Size() == 0 || w2.Size() == 0) { + return Weight::One(); + } else if (w1 == Weight::Zero()) { + return Weight(iter2.Value()); + } else if (w2 == Weight::Zero()) { + return Weight(iter1.Value()); + } else if (iter1.Value() == iter2.Value()) { + return Weight(iter1.Value()); + } else { + return Weight::One(); + } + } +}; + +// The gallic common divisor uses the label common divisor on the string +// component and the common divisor on the weight component, which defaults to +// the default common divisor. +template > +class GallicCommonDivisor { + public: + using Weight = GallicWeight; + + Weight operator()(const Weight &w1, const Weight &w2) const { + return Weight(label_common_divisor_(w1.Value1(), w2.Value1()), + weight_common_divisor_(w1.Value2(), w2.Value2())); + } + + private: + LabelCommonDivisor label_common_divisor_; + CommonDivisor weight_common_divisor_; +}; + +// Specialization for general GALLIC weight. +template +class GallicCommonDivisor { + public: + using Weight = GallicWeight; + using GRWeight = GallicWeight; + using Iterator = + UnionWeightIterator>; + + Weight operator()(const Weight &w1, const Weight &w2) const { + auto weight = GRWeight::Zero(); + for (Iterator iter(w1); !iter.Done(); iter.Next()) { + weight = common_divisor_(weight, iter.Value()); + } + for (Iterator iter(w2); !iter.Done(); iter.Next()) { + weight = common_divisor_(weight, iter.Value()); + } + return weight == GRWeight::Zero() ? Weight::Zero() : Weight(weight); + } + + private: + GallicCommonDivisor common_divisor_; +}; + +namespace internal { + +// Represents an element in a subset +template +struct DeterminizeElement { + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + DeterminizeElement(StateId s, Weight weight) + : state_id(s), weight(std::move(weight)) {} + + inline bool operator==(const DeterminizeElement &element) const { + return state_id == element.state_id && weight == element.weight; + } + + inline bool operator!=(const DeterminizeElement &element) const { + return !(*this == element); + } + + inline bool operator<(const DeterminizeElement &element) const { + return state_id < element.state_id; + } + + StateId state_id; // Input state ID. + Weight weight; // Residual weight. +}; + +// Represents a weighted subset and determinization filter state +template +struct DeterminizeStateTuple { + using Arc = A; + using Element = DeterminizeElement; + using Subset = std::forward_list; + + DeterminizeStateTuple() : filter_state(FilterState::NoState()) {} + + inline bool operator==( + const DeterminizeStateTuple &tuple) const { + return (tuple.filter_state == filter_state) && (tuple.subset == subset); + } + + inline bool operator!=( + const DeterminizeStateTuple &tuple) const { + return (tuple.filter_state != filter_state) || (tuple.subset != subset); + } + + Subset subset; + FilterState filter_state; +}; + +// Proto-transition for determinization. +template +struct DeterminizeArc { + using Arc = typename StateTuple::Arc; + using Label = typename Arc::Label; + using Weight = typename Arc::Weight; + + DeterminizeArc() + : label(kNoLabel), weight(Weight::Zero()), dest_tuple(nullptr) {} + + explicit DeterminizeArc(const Arc &arc) + : label(arc.ilabel), weight(Weight::Zero()), dest_tuple(new StateTuple) {} + + Label label; // Arc label. + Weight weight; // Arc weight. + StateTuple *dest_tuple; // Destination subset and filter state. +}; + +} // namespace internal + +// Determinization filters are used to compute destination state tuples based +// on the source tuple, transition, and destination element or on similar +// super-final transition information. The filter operates on a map between a +// label and the corresponding destination state tuples. It must define the map +// type LabelMap. The default filter is used for weighted determinization. +// A determinize filter for implementing weighted determinization. +template +class DefaultDeterminizeFilter { + public: + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using FilterState = CharFilterState; + using Element = internal::DeterminizeElement; + using StateTuple = internal::DeterminizeStateTuple; + using LabelMap = std::map>; + + // This is needed e.g. to go into the gallic domain for transducers. + template + struct rebind { + using Other = DefaultDeterminizeFilter; + }; + + explicit DefaultDeterminizeFilter(const Fst &fst) : fst_(fst.Copy()) {} + + // This is needed (e.g.) to go into the gallic domain for transducers. + // Ownership of the templated filter argument is given to this class. + template + DefaultDeterminizeFilter(const Fst &fst, Filter *filter) + : fst_(fst.Copy()) { + delete filter; + } + + // Copy constructor; the FST can be passed if it has been deep-copied. + DefaultDeterminizeFilter(const DefaultDeterminizeFilter &filter, + const Fst *fst = nullptr) + : fst_(fst ? fst->Copy() : filter.fst_->Copy()) {} + + FilterState Start() const { return FilterState(0); } + + // Does no work. + void SetState(StateId s, const StateTuple &tuple) {} + + // Filters transition, possibly modifying label map. Returns true if arc is + // added to the label map. + bool FilterArc(const Arc &arc, const Element &src_element, + const Element &dest_element, LabelMap *label_map) const { + // Adds element to unique state tuple for arc label. + auto &det_arc = (*label_map)[arc.ilabel]; + if (det_arc.label == kNoLabel) { + det_arc = internal::DeterminizeArc(arc); + det_arc.dest_tuple->filter_state = FilterState(0); + } + det_arc.dest_tuple->subset.push_front(dest_element); + return true; + } + + // Filters super-final transition, returning new final weight. + Weight FilterFinal(Weight weight, const Element &element) { return weight; } + + static uint64 Properties(uint64 props) { return props; } + + private: + std::unique_ptr> fst_; +}; + +// Determinization state table interface: +// +// template +// class DeterminizeStateTable { +// public: +// using StateId = typename Arc::StateId; +// using StateTuple = internal::DeterminizeStateTuple; +// +// // Required sub-class. This is needed (e.g.) to go into the gallic domain. +// template +// struct rebind { +// using Other = DeterminizeStateTable; +// } +// +// // Required constuctor. +// DeterminizeStateTable(); +// +// // Required copy constructor that does not copy state. +// DeterminizeStateTable(const DeterminizeStateTable +// &table); +// +// // Looks up state ID by state tuple; if it doesn't exist, then adds it. +// // FindState takes ownership of the state tuple argument so that it +// // doesn't have to copy it if it creates a new state. +// StateId FindState(StateTuple *tuple); +// +// // Looks up state tuple by ID. +// const StateTuple *Tuple(StateId id) const; +// }; + +// The default determinization state table based on the compact hash bi-table. +template +class DefaultDeterminizeStateTable { + public: + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using StateTuple = internal::DeterminizeStateTuple; + using Element = typename StateTuple::Element; + using Subset = typename StateTuple::Subset; + + template + struct rebind { + using Other = DefaultDeterminizeStateTable; + }; + + explicit DefaultDeterminizeStateTable(size_t table_size = 0) + : table_size_(table_size), tuples_(table_size_) {} + + DefaultDeterminizeStateTable( + const DefaultDeterminizeStateTable &table) + : table_size_(table.table_size_), tuples_(table_size_) {} + + ~DefaultDeterminizeStateTable() { + for (StateId s = 0; s < tuples_.Size(); ++s) delete tuples_.FindEntry(s); + } + + // Finds the state corresponding to a state tuple. Only creates a new state if + // the tuple is not found. FindState takes ownership of the tuple argument so + // that it doesn't have to copy it if it creates a new state. + StateId FindState(StateTuple *tuple) { + const StateId ns = tuples_.Size(); + const auto s = tuples_.FindId(tuple); + if (s != ns) delete tuple; // Tuple found. + return s; + } + + const StateTuple *Tuple(StateId s) { return tuples_.FindEntry(s); } + + private: + // Comparison object for StateTuples. + class StateTupleEqual { + public: + bool operator()(const StateTuple *tuple1, const StateTuple *tuple2) const { + return *tuple1 == *tuple2; + } + }; + + // Hash function for StateTuples. + class StateTupleKey { + public: + size_t operator()(const StateTuple *tuple) const { + size_t h = tuple->filter_state.Hash(); + for (auto it = tuple->subset.begin(); it != tuple->subset.end(); ++it) { + const size_t h1 = it->state_id; + static constexpr auto lshift = 5; + static constexpr auto rshift = CHAR_BIT * sizeof(size_t) - 5; + h ^= h << 1 ^ h1 << lshift ^ h1 >> rshift ^ it->weight.Hash(); + } + return h; + } + }; + + size_t table_size_; + CompactHashBiTable + tuples_; + + DefaultDeterminizeStateTable &operator=( + const DefaultDeterminizeStateTable &) = delete; +}; + +// Determinization type. +enum DeterminizeType { + // Input transducer is known to be functional (or error). + DETERMINIZE_FUNCTIONAL, // Input transducer is functional (error if not). + // Input transducer is not known to be functional. + DETERMINIZE_NONFUNCTIONAL, + // Input transducer is not known to be functional but only keep the min of + // of ambiguous outputs. + DETERMINIZE_DISAMBIGUATE +}; + +// Options for finite-state transducer determinization templated on the arc +// type, common divisor, the determinization filter and the state table. +// DeterminizeFst takes ownership of the determinization filter and state table, +// if provided. +template , + class Filter = DefaultDeterminizeFilter, + class StateTable = + DefaultDeterminizeStateTable> +struct DeterminizeFstOptions : public CacheOptions { + using Label = typename Arc::Label; + + float delta; // Quantization delta for subset weights. + Label subsequential_label; // Label used for residual final output + // when producing subsequential transducers. + DeterminizeType type; // Determinization type. + bool increment_subsequential_label; // When creating several subsequential + // arcs at a given state, make their + // label distinct by incrementing. + Filter *filter; // Determinization filter; + // DeterminizeFst takes ownership. + StateTable *state_table; // Determinization state table; + // DeterminizeFst takes ownership. + + explicit DeterminizeFstOptions(const CacheOptions &opts, float delta = kDelta, + Label subsequential_label = 0, + DeterminizeType type = DETERMINIZE_FUNCTIONAL, + bool increment_subsequential_label = false, + Filter *filter = nullptr, + StateTable *state_table = nullptr) + : CacheOptions(opts), + delta(delta), + subsequential_label(subsequential_label), + type(type), + increment_subsequential_label(increment_subsequential_label), + filter(filter), + state_table(state_table) {} + + explicit DeterminizeFstOptions(float delta = kDelta, + Label subsequential_label = 0, + DeterminizeType type = DETERMINIZE_FUNCTIONAL, + bool increment_subsequential_label = false, + Filter *filter = nullptr, + StateTable *state_table = nullptr) + : delta(delta), + subsequential_label(subsequential_label), + type(type), + increment_subsequential_label(increment_subsequential_label), + filter(filter), + state_table(state_table) {} +}; + +namespace internal { + +// Implementation of delayed DeterminizeFst. This base class is +// common to the variants that implement acceptor and transducer +// determinization. +template +class DeterminizeFstImplBase : public CacheImpl { + public: + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using Store = DefaultCacheStore; + using State = typename Store::State; + + using FstImpl::SetType; + using FstImpl::SetProperties; + using FstImpl::Properties; + using FstImpl::SetInputSymbols; + using FstImpl::SetOutputSymbols; + + using CacheBaseImpl>::HasStart; + using CacheBaseImpl>::HasFinal; + using CacheBaseImpl>::HasArcs; + using CacheBaseImpl>::SetFinal; + using CacheBaseImpl>::SetStart; + + template + DeterminizeFstImplBase( + const Fst &fst, + const DeterminizeFstOptions &opts) + : CacheImpl(opts), fst_(fst.Copy()) { + SetType("determinize"); + const auto iprops = fst.Properties(kFstProperties, false); + const auto dprops = + DeterminizeProperties(iprops, opts.subsequential_label != 0, + opts.type == DETERMINIZE_NONFUNCTIONAL + ? opts.increment_subsequential_label + : true); + SetProperties(Filter::Properties(dprops), kCopyProperties); + SetInputSymbols(fst.InputSymbols()); + SetOutputSymbols(fst.OutputSymbols()); + } + + DeterminizeFstImplBase(const DeterminizeFstImplBase &impl) + : CacheImpl(impl), fst_(impl.fst_->Copy(true)) { + SetType("determinize"); + SetProperties(impl.Properties(), kCopyProperties); + SetInputSymbols(impl.InputSymbols()); + SetOutputSymbols(impl.OutputSymbols()); + } + + virtual DeterminizeFstImplBase *Copy() const = 0; + + StateId Start() { + if (!HasStart()) { + const auto start = ComputeStart(); + if (start != kNoStateId) SetStart(start); + } + return CacheImpl::Start(); + } + + Weight Final(StateId s) { + if (!HasFinal(s)) SetFinal(s, ComputeFinal(s)); + return CacheImpl::Final(s); + } + + virtual void Expand(StateId s) = 0; + + size_t NumArcs(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumArcs(s); + } + + size_t NumInputEpsilons(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumInputEpsilons(s); + } + + size_t NumOutputEpsilons(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumOutputEpsilons(s); + } + + void InitArcIterator(StateId s, ArcIteratorData *data) { + if (!HasArcs(s)) Expand(s); + CacheImpl::InitArcIterator(s, data); + } + + virtual StateId ComputeStart() = 0; + + virtual Weight ComputeFinal(StateId s) = 0; + + const Fst &GetFst() const { return *fst_; } + + private: + std::unique_ptr> fst_; // Input FST. +}; + +// Implementation of delayed determinization for weighted acceptors. +template +class DeterminizeFsaImpl : public DeterminizeFstImplBase { + public: + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using FilterState = typename Filter::FilterState; + using StateTuple = internal::DeterminizeStateTuple; + using Element = typename StateTuple::Element; + using Subset = typename StateTuple::Subset; + using LabelMap = typename Filter::LabelMap; + + using FstImpl::SetProperties; + using DeterminizeFstImplBase::GetFst; + using DeterminizeFstImplBase::SetArcs; + + DeterminizeFsaImpl( + const Fst &fst, const std::vector *in_dist, + std::vector *out_dist, + const DeterminizeFstOptions &opts) + : DeterminizeFstImplBase(fst, opts), + delta_(opts.delta), + in_dist_(in_dist), + out_dist_(out_dist), + filter_(opts.filter ? opts.filter : new Filter(fst)), + state_table_(opts.state_table ? opts.state_table : new StateTable()) { + if (!fst.Properties(kAcceptor, true)) { + FSTERROR() << "DeterminizeFst: Argument not an acceptor"; + SetProperties(kError, kError); + } + if (!(Weight::Properties() & kLeftSemiring)) { + FSTERROR() << "DeterminizeFst: Weight must be left distributive: " + << Weight::Type(); + SetProperties(kError, kError); + } + if (out_dist_) out_dist_->clear(); + } + + DeterminizeFsaImpl( + const DeterminizeFsaImpl &impl) + : DeterminizeFstImplBase(impl), + delta_(impl.delta_), + in_dist_(nullptr), + out_dist_(nullptr), + filter_(new Filter(*impl.filter_, &GetFst())), + state_table_(new StateTable(*impl.state_table_)) { + if (impl.out_dist_) { + FSTERROR() << "DeterminizeFsaImpl: Cannot copy with out_dist vector"; + SetProperties(kError, kError); + } + } + + DeterminizeFsaImpl *Copy() + const override { + return new DeterminizeFsaImpl( + *this); + } + + uint64 Properties() const override { return Properties(kFstProperties); } + + // Sets error if found, and returns other FST impl properties. + uint64 Properties(uint64 mask) const override { + if ((mask & kError) && (GetFst().Properties(kError, false))) { + SetProperties(kError, kError); + } + return FstImpl::Properties(mask); + } + + StateId ComputeStart() override { + const auto s = GetFst().Start(); + if (s == kNoStateId) return kNoStateId; + const Element element(s, Weight::One()); + auto *tuple = new StateTuple; + tuple->subset.push_front(element); + tuple->filter_state = filter_->Start(); + return FindState(tuple); + } + + Weight ComputeFinal(StateId s) override { + const auto *tuple = state_table_->Tuple(s); + filter_->SetState(s, *tuple); + auto final_weight = Weight::Zero(); + for (auto it = tuple->subset.begin(); it != tuple->subset.end(); ++it) { + const auto &element = *it; + final_weight = + Plus(final_weight, + Times(element.weight, GetFst().Final(element.state_id))); + final_weight = filter_->FilterFinal(final_weight, element); + if (!final_weight.Member()) SetProperties(kError, kError); + } + return final_weight; + } + + StateId FindState(StateTuple *tuple) { + const auto s = state_table_->FindState(tuple); + if (in_dist_ && out_dist_->size() <= s) { + out_dist_->push_back(ComputeDistance(tuple->subset)); + } + return s; + } + + // Computes distance from a state to the final states in the DFA given the + // distances in the NFA. + Weight ComputeDistance(const Subset &subset) { + auto outd = Weight::Zero(); + for (auto it = subset.begin(); it != subset.end(); ++it) { + const auto &element = *it; + const auto ind = + (element.state_id < in_dist_->size() ? (*in_dist_)[element.state_id] + : Weight::Zero()); + outd = Plus(outd, Times(element.weight, ind)); + } + return outd; + } + + // Computes the outgoing transitions from a state, creating new destination + // states as needed. + void Expand(StateId s) override { + LabelMap label_map; + GetLabelMap(s, &label_map); + for (auto it = label_map.begin(); it != label_map.end(); ++it) { + AddArc(s, it->second); + } + SetArcs(s); + } + + private: + using DetArc = internal::DeterminizeArc; + + // Constructs proto-determinization transition, including destination subset, + // per label. + void GetLabelMap(StateId s, LabelMap *label_map) { + const auto *src_tuple = state_table_->Tuple(s); + filter_->SetState(s, *src_tuple); + for (auto it = src_tuple->subset.begin(); it != src_tuple->subset.end(); + ++it) { + const auto &src_element = *it; + for (ArcIterator> aiter(GetFst(), src_element.state_id); + !aiter.Done(); aiter.Next()) { + const auto &arc = aiter.Value(); + const Element dest_element(arc.nextstate, + Times(src_element.weight, arc.weight)); + filter_->FilterArc(arc, src_element, dest_element, label_map); + } + } + for (auto it = label_map->begin(); it != label_map->end(); ++it) { + NormArc(&it->second); + } + } + + // Sorts subsets and removes duplicate elements, normalizing transition and + // subset weights. + void NormArc(DetArc *det_arc) { + auto *dest_tuple = det_arc->dest_tuple; + dest_tuple->subset.sort(); + auto piter = dest_tuple->subset.begin(); + for (auto diter = dest_tuple->subset.begin(); + diter != dest_tuple->subset.end();) { + auto &dest_element = *diter; + auto &prev_element = *piter; + // Computes arc weight. + det_arc->weight = common_divisor_(det_arc->weight, dest_element.weight); + if (piter != diter && dest_element.state_id == prev_element.state_id) { + // Found duplicate state: sums state weight and deletes duplicate. + prev_element.weight = Plus(prev_element.weight, dest_element.weight); + if (!prev_element.weight.Member()) SetProperties(kError, kError); + ++diter; + dest_tuple->subset.erase_after(piter); + } else { + piter = diter; + ++diter; + } + } + // Divides out label weight from destination subset elements, quantizing to + // ensure comparisons are effective. + for (auto diter = dest_tuple->subset.begin(); + diter != dest_tuple->subset.end(); ++diter) { + auto &dest_element = *diter; + dest_element.weight = + Divide(dest_element.weight, det_arc->weight, DIVIDE_LEFT); + dest_element.weight = dest_element.weight.Quantize(delta_); + } + } + + // Adds an arc from state S to the destination state associated with state + // tuple in det_arc as created by GetLabelMap. + void AddArc(StateId s, const DetArc &det_arc) { + const Arc arc(det_arc.label, det_arc.label, det_arc.weight, + FindState(det_arc.dest_tuple)); + CacheImpl::PushArc(s, arc); + } + + float delta_; // Quantization delta for weights. + const std::vector *in_dist_; // Distance to final NFA states. + std::vector *out_dist_; // Distance to final DFA states. + + // FIXME(kbg): Ought to be static const? + CommonDivisor common_divisor_; + std::unique_ptr filter_; + std::unique_ptr state_table_; +}; + +// Implementation of delayed determinization for transducers. Transducer +// determinization is implemented by mapping the input to the Gallic semiring as +// an acceptor whose weights contain the output strings and using acceptor +// determinization above to determinize that acceptor. +template +class DeterminizeFstImpl : public DeterminizeFstImplBase { + public: + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using ToMapper = ToGallicMapper; + using ToArc = typename ToMapper::ToArc; + using ToFst = ArcMapFst; + using FromMapper = FromGallicMapper; + using FromFst = ArcMapFst; + + using ToCommonDivisor = GallicCommonDivisor; + using ToFilter = typename Filter::template rebind::Other; + using ToFilterState = typename ToFilter::FilterState; + using ToStateTable = + typename StateTable::template rebind::Other; + using FactorIterator = GallicFactor; + + using FstImpl::SetProperties; + using DeterminizeFstImplBase::GetFst; + using CacheBaseImpl>::GetCacheGc; + using CacheBaseImpl>::GetCacheLimit; + + DeterminizeFstImpl( + const Fst &fst, + const DeterminizeFstOptions &opts) + : DeterminizeFstImplBase(fst, opts), + delta_(opts.delta), + subsequential_label_(opts.subsequential_label), + increment_subsequential_label_(opts.increment_subsequential_label) { + if (opts.state_table) { + FSTERROR() << "DeterminizeFst: " + << "A state table can not be passed with transducer input"; + SetProperties(kError, kError); + return; + } + Init(GetFst(), opts.filter); + } + + DeterminizeFstImpl( + const DeterminizeFstImpl &impl) + : DeterminizeFstImplBase(impl), + delta_(impl.delta_), + subsequential_label_(impl.subsequential_label_), + increment_subsequential_label_(impl.increment_subsequential_label_) { + Init(GetFst(), nullptr); + } + + DeterminizeFstImpl *Copy() + const override { + return new DeterminizeFstImpl( + *this); + } + + uint64 Properties() const override { return Properties(kFstProperties); } + + // Sets error if found, and returns other FST impl properties. + uint64 Properties(uint64 mask) const override { + if ((mask & kError) && (GetFst().Properties(kError, false) || + from_fst_->Properties(kError, false))) { + SetProperties(kError, kError); + } + return FstImpl::Properties(mask); + } + + StateId ComputeStart() override { return from_fst_->Start(); } + + Weight ComputeFinal(StateId s) override { return from_fst_->Final(s); } + + void Expand(StateId s) override { + for (ArcIterator aiter(*from_fst_, s); !aiter.Done(); + aiter.Next()) { + CacheImpl::PushArc(s, aiter.Value()); + } + CacheImpl::SetArcs(s); + } + + private: + // Initialization of transducer determinization implementation, which is + // defined after DeterminizeFst since it calls it. + void Init(const Fst &fst, Filter *filter); + + float delta_; + Label subsequential_label_; + bool increment_subsequential_label_; + std::unique_ptr from_fst_; +}; + +} // namespace internal + +// Determinizes a weighted transducer. This version is a delayed +// FST. The result will be an equivalent FST that has the property +// that no state has two transitions with the same input label. +// For this algorithm, epsilon transitions are treated as regular +// symbols (cf. RmEpsilon). +// +// The transducer must be functional. The weights must be (weakly) left +// divisible (valid for TropicalWeight and LogWeight for instance) and be +// zero-sum-free if for all a, b: (Plus(a, b) == 0) => a = b = 0. +// +// Complexity: +// +// Determinizable: exponential (polynomial in the size of the output). +// Non-determinizable: does not terminate. +// +// The determinizable automata include all unweighted and all acyclic input. +// +// For more information, see: +// +// Mohri, M. 1997. Finite-state transducers in language and speech processing. +// Computational Linguistics 23(2): 269-311. +// +// This class attaches interface to implementation and handles reference +// counting, delegating most methods to ImplToFst. +template +class DeterminizeFst : public ImplToFst> { + public: + using Arc = A; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using Store = DefaultCacheStore; + using State = typename Store::State; + using Impl = internal::DeterminizeFstImplBase; + + friend class ArcIterator>; + friend class StateIterator>; + + template + friend class DeterminizeFstImpl; + + explicit DeterminizeFst(const Fst &fst) + : ImplToFst(CreateImpl(fst)) {} + + template + DeterminizeFst( + const Fst &fst, + const DeterminizeFstOptions + &opts = + DeterminizeFstOptions()) + : ImplToFst(CreateImpl(fst, opts)) {} + + // This acceptor-only version additionally computes the distance to final + // states in the output if provided with those distances for the input; this + // is useful for e.g., computing the k-shortest unique paths. + template + DeterminizeFst( + const Fst &fst, const std::vector *in_dist, + std::vector *out_dist, + const DeterminizeFstOptions + &opts = + DeterminizeFstOptions()) + : ImplToFst( + std::make_shared>( + fst, in_dist, out_dist, opts)) { + if (!fst.Properties(kAcceptor, true)) { + FSTERROR() << "DeterminizeFst: " + << "Distance to final states computed for acceptors only"; + GetMutableImpl()->SetProperties(kError, kError); + } + } + + // See Fst<>::Copy() for doc. + DeterminizeFst(const DeterminizeFst &fst, bool safe = false) + : ImplToFst(safe ? std::shared_ptr(fst.GetImpl()->Copy()) + : fst.GetSharedImpl()) {} + + // Get a copy of this DeterminizeFst. See Fst<>::Copy() for further doc. + DeterminizeFst *Copy(bool safe = false) const override { + return new DeterminizeFst(*this, safe); + } + + inline void InitStateIterator(StateIteratorData *data) const override; + + void InitArcIterator(StateId s, ArcIteratorData *data) const override { + GetMutableImpl()->InitArcIterator(s, data); + } + + private: + using ImplToFst::GetImpl; + using ImplToFst::GetMutableImpl; + + static std::shared_ptr CreateImpl(const Fst &fst) { + using D = DefaultCommonDivisor; + using F = DefaultDeterminizeFilter; + using T = DefaultDeterminizeStateTable; + const DeterminizeFstOptions opts; + return CreateImpl(fst, opts); + } + + template + static std::shared_ptr CreateImpl( + const Fst &fst, + const DeterminizeFstOptions + &opts) { + if (fst.Properties(kAcceptor, true)) { + // Calls implementation for acceptors. + return std::make_shared< + internal::DeterminizeFsaImpl>( + fst, nullptr, nullptr, opts); + } else if (opts.type == DETERMINIZE_DISAMBIGUATE) { + auto rv = std::make_shared>(fst, opts); + if (!(Weight::Properties() & kPath)) { + FSTERROR() << "DeterminizeFst: Weight needs to have the " + << "path property to disambiguate output: " + << Weight::Type(); + rv->SetProperties(kError, kError); + } + // Calls disambiguating implementation for non-functional transducers. + return rv; + } else if (opts.type == DETERMINIZE_FUNCTIONAL) { + // Calls implementation for functional transducers. + return std::make_shared>(fst, opts); + } else { // opts.type == DETERMINIZE_NONFUNCTIONAL + // Calls implementation for non functional transducers; + return std::make_shared>(fst, opts); + } + } + + DeterminizeFst &operator=(const DeterminizeFst &) = delete; +}; + +namespace internal { + +// Initialization of transducer determinization implementation, which is defined +// after DeterminizeFst since it calls it. +template +void DeterminizeFstImpl::Init(const Fst &fst, F *filter) { + // Mapper to an acceptor. + const ToFst to_fst(fst, ToMapper()); + auto *to_filter = filter ? new ToFilter(to_fst, filter) : nullptr; + // This recursive call terminates since it is to a (non-recursive) + // different constructor. + const CacheOptions copts(GetCacheGc(), GetCacheLimit()); + const DeterminizeFstOptions + dopts(copts, delta_, 0, DETERMINIZE_FUNCTIONAL, false, to_filter); + // Uses acceptor-only constructor to avoid template recursion. + const DeterminizeFst det_fsa(to_fst, nullptr, nullptr, dopts); + // Mapper back to transducer. + const FactorWeightOptions fopts( + CacheOptions(true, 0), delta_, kFactorFinalWeights, subsequential_label_, + subsequential_label_, increment_subsequential_label_, + increment_subsequential_label_); + const FactorWeightFst factored_fst(det_fsa, fopts); + from_fst_.reset(new FromFst(factored_fst, FromMapper(subsequential_label_))); +} + +} // namespace internal + +// Specialization for DeterminizeFst. +template +class StateIterator> + : public CacheStateIterator> { + public: + explicit StateIterator(const DeterminizeFst &fst) + : CacheStateIterator>(fst, fst.GetMutableImpl()) {} +}; + +// Specialization for DeterminizeFst. +template +class ArcIterator> + : public CacheArcIterator> { + public: + using StateId = typename Arc::StateId; + + ArcIterator(const DeterminizeFst &fst, StateId s) + : CacheArcIterator>(fst.GetMutableImpl(), s) { + if (!fst.GetImpl()->HasArcs(s)) fst.GetMutableImpl()->Expand(s); + } +}; + +template +inline void DeterminizeFst::InitStateIterator( + StateIteratorData *data) const { + data->base = new StateIterator>(*this); +} + +// Useful aliases when using StdArc. +using StdDeterminizeFst = DeterminizeFst; + +template +struct DeterminizeOptions { + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + float delta; // Quantization delta for subset weights. + Weight weight_threshold; // Pruning weight threshold. + StateId state_threshold; // Pruning state threshold. + Label subsequential_label; // Label used for residual final output. + DeterminizeType type; + bool increment_subsequential_label; // When creating several subsequential + // arcs at a given state, make their + // label distinct by incrementation? + + explicit DeterminizeOptions(float delta = kDelta, + Weight weight_threshold = Weight::Zero(), + StateId state_threshold = kNoStateId, + Label subsequential_label = 0, + DeterminizeType type = DETERMINIZE_FUNCTIONAL, + bool increment_subsequential_label = false) + : delta(delta), + weight_threshold(std::move(weight_threshold)), + state_threshold(state_threshold), + subsequential_label(subsequential_label), + type(type), + increment_subsequential_label(increment_subsequential_label) {} +}; + +// Determinizes a weighted transducer. This version writes the +// determinized Fst to an output MutableFst. The result will be an +// equivalent FST that has the property that no state has two +// transitions with the same input label. For this algorithm, epsilon +// transitions are treated as regular symbols (cf. RmEpsilon). +// +// The transducer must be functional. The weights must be (weakly) +// left divisible (valid for TropicalWeight and LogWeight). +// +// Complexity: +// +// Determinizable: exponential (polynomial in the size of the output) +// Non-determinizable: does not terminate +// +// The determinizable automata include all unweighted and all acyclic input. +template +void Determinize( + const Fst &ifst, MutableFst *ofst, + const DeterminizeOptions &opts = DeterminizeOptions()) { + using Weight = typename Arc::Weight; + DeterminizeFstOptions nopts; + nopts.delta = opts.delta; + nopts.subsequential_label = opts.subsequential_label; + nopts.type = opts.type; + nopts.increment_subsequential_label = opts.increment_subsequential_label; + nopts.gc_limit = 0; // Caches only the last state for fastest copy. + if (opts.weight_threshold != Weight::Zero() || + opts.state_threshold != kNoStateId) { + if (ifst.Properties(kAcceptor, false)) { + std::vector idistance; + std::vector odistance; + ShortestDistance(ifst, &idistance, true); + DeterminizeFst dfst(ifst, &idistance, &odistance, nopts); + PruneOptions> popts( + opts.weight_threshold, opts.state_threshold, AnyArcFilter(), + &odistance); + Prune(dfst, ofst, popts); + } else { + *ofst = DeterminizeFst(ifst, nopts); + Prune(ofst, opts.weight_threshold, opts.state_threshold); + } + } else { + *ofst = DeterminizeFst(ifst, nopts); + } +} + +} // namespace fst + +#endif // FST_DETERMINIZE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/dfs-visit.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/dfs-visit.h new file mode 100644 index 0000000000..d138ab6202 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/dfs-visit.h @@ -0,0 +1,204 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Depth-first search visitation. See visit.h for more general search queue +// disciplines. + +#ifndef FST_DFS_VISIT_H_ +#define FST_DFS_VISIT_H_ + +#include +#include + +#include +#include + + +namespace fst { + +// Visitor Interface: class determining actions taken during a depth-first +// search-style visit. If any of the boolean member functions return false, the +// DFS is aborted by first calling FinishState() on all currently grey states +// and then calling FinishVisit(). +// +// This is similar to the more general visitor interface in visit.h, except +// that FinishState returns additional information appropriate only for a DFS +// and some methods names here are better suited to a DFS. +// +// template +// class Visitor { +// public: +// using StateId = typename Arc::StateId; +// +// Visitor(T *return_data); +// +// // Invoked before DFS visit. +// void InitVisit(const Fst &fst); +// +// // Invoked when state discovered (2nd arg is DFS tree root). +// bool InitState(StateId s, StateId root); +// +// // Invoked when tree arc to white/undiscovered state examined. +// bool TreeArc(StateId s, const Arc &arc); +// +// // Invoked when back arc to grey/unfinished state examined. +// bool BackArc(StateId s, const Arc &arc); +// +// // Invoked when forward or cross arc to black/finished state examined. +// bool ForwardOrCrossArc(StateId s, const Arc &arc); +// +// // Invoked when state finished ('s' is tree root, 'parent' is kNoStateId, +// // and 'arc' is nullptr). +// void FinishState(StateId s, StateId parent, const Arc *arc); +// +// // Invoked after DFS visit. +// void FinishVisit(); +// }; + +namespace internal { + +// An FST state's DFS stack state. +template +struct DfsState { + using Arc = typename FST::Arc; + using StateId = typename Arc::StateId; + + DfsState(const FST &fst, StateId s) : state_id(s), arc_iter(fst, s) {} + + void *operator new(size_t size, MemoryPool> *pool) { + return pool->Allocate(); + } + + static void Destroy(DfsState *dfs_state, + MemoryPool> *pool) { + if (dfs_state) { + dfs_state->~DfsState(); + pool->Free(dfs_state); + } + } + + StateId state_id; // FST state. + ArcIterator arc_iter; // The corresponding arcs. +}; + +} // namespace internal + +// Performs depth-first visitation. Visitor class argument determines actions +// and contains any return data. ArcFilter determines arcs that are considered. +// If 'access_only' is true, performs visitation only to states accessible from +// the initial state. +// +// Note this is similar to Visit() in visit.h called with a LIFO queue, except +// this version has a Visitor class specialized and augmented for a DFS. +template +void DfsVisit(const FST &fst, Visitor *visitor, ArcFilter filter, + bool access_only = false) { + using Arc = typename FST::Arc; + using StateId = typename Arc::StateId; + visitor->InitVisit(fst); + const auto start = fst.Start(); + if (start == kNoStateId) { + visitor->FinishVisit(); + return; + } + // An FST state's DFS status + static constexpr uint8 kDfsWhite = 0; // Undiscovered. + static constexpr uint8 kDfsGrey = 1; // Discovered but unfinished. + static constexpr uint8 kDfsBlack = 2; // Finished. + std::vector state_color; + std::stack *> state_stack; // DFS execution stack. + MemoryPool> state_pool; // Pool for DFSStates. + auto nstates = start + 1; // Number of known states in general case. + bool expanded = false; + if (fst.Properties(kExpanded, false)) { // Tests if expanded case, then + nstates = CountStates(fst); // uses ExpandedFst::NumStates(). + expanded = true; + } + state_color.resize(nstates, kDfsWhite); + StateIterator siter(fst); + // Continue DFS while true. + bool dfs = true; + // Iterate over trees in DFS forest. + for (auto root = start; dfs && root < nstates;) { + state_color[root] = kDfsGrey; + state_stack.push(new (&state_pool) internal::DfsState(fst, root)); + dfs = visitor->InitState(root, root); + while (!state_stack.empty()) { + auto *dfs_state = state_stack.top(); + const auto s = dfs_state->state_id; + if (s >= state_color.size()) { + nstates = s + 1; + state_color.resize(nstates, kDfsWhite); + } + ArcIterator &aiter = dfs_state->arc_iter; + if (!dfs || aiter.Done()) { + state_color[s] = kDfsBlack; + internal::DfsState::Destroy(dfs_state, &state_pool); + state_stack.pop(); + if (!state_stack.empty()) { + auto *parent_state = state_stack.top(); + auto &piter = parent_state->arc_iter; + visitor->FinishState(s, parent_state->state_id, &piter.Value()); + piter.Next(); + } else { + visitor->FinishState(s, kNoStateId, nullptr); + } + continue; + } + const auto &arc = aiter.Value(); + if (arc.nextstate >= state_color.size()) { + nstates = arc.nextstate + 1; + state_color.resize(nstates, kDfsWhite); + } + if (!filter(arc)) { + aiter.Next(); + continue; + } + const auto next_color = state_color[arc.nextstate]; + switch (next_color) { + default: + case kDfsWhite: + dfs = visitor->TreeArc(s, arc); + if (!dfs) break; + state_color[arc.nextstate] = kDfsGrey; + state_stack.push(new (&state_pool) + internal::DfsState(fst, arc.nextstate)); + dfs = visitor->InitState(arc.nextstate, root); + break; + case kDfsGrey: + dfs = visitor->BackArc(s, arc); + aiter.Next(); + break; + case kDfsBlack: + dfs = visitor->ForwardOrCrossArc(s, arc); + aiter.Next(); + break; + } + } + if (access_only) break; + // Finds next tree root. + for (root = root == start ? 0 : root + 1; + root < nstates && state_color[root] != kDfsWhite; ++root) { + } + // Checks for a state beyond the largest known state. + if (!expanded && root == nstates) { + for (; !siter.Done(); siter.Next()) { + if (siter.Value() == nstates) { + ++nstates; + state_color.push_back(kDfsWhite); + break; + } + } + } + } + visitor->FinishVisit(); +} + +template +void DfsVisit(const Fst &fst, Visitor *visitor) { + DfsVisit(fst, visitor, AnyArcFilter()); +} + +} // namespace fst + +#endif // FST_DFS_VISIT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/difference.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/difference.h new file mode 100644 index 0000000000..bfe1321345 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/difference.h @@ -0,0 +1,177 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Class to compute the difference between two FSAs. + +#ifndef FST_DIFFERENCE_H_ +#define FST_DIFFERENCE_H_ + +#include + + +#include +#include +#include + + +namespace fst { + +template >, + class Filter = SequenceComposeFilter, + class StateTable = + GenericComposeStateTable> +struct DifferenceFstOptions + : public ComposeFstOptions { + explicit DifferenceFstOptions(const CacheOptions &opts = CacheOptions(), + M *matcher1 = nullptr, M *matcher2 = nullptr, + Filter *filter = nullptr, + StateTable *state_table = nullptr) + : ComposeFstOptions(opts, matcher1, matcher2, + filter, state_table) {} +}; + +// Computes the difference between two FSAs. This version is a delayed FST. +// Only strings that are in the first automaton but not in second are retained +// in the result. +// +// The first argument must be an acceptor; the second argument must be an +// unweighted, epsilon-free, deterministic acceptor. One of the arguments must +// be label-sorted. +// +// Complexity: same as ComposeFst. +// +// Caveats: same as ComposeFst. +template +class DifferenceFst : public ComposeFst { + public: + using Arc = A; + using Weight = typename Arc::Weight; + using StateId = typename Arc::StateId; + + using ComposeFst::CreateBase1; + + // A - B = A ^ B'. + DifferenceFst(const Fst &fst1, const Fst &fst2, + const CacheOptions &opts = CacheOptions()) + : ComposeFst(CreateDifferenceImplWithCacheOpts(fst1, fst2, opts)) { + if (!fst1.Properties(kAcceptor, true)) { + FSTERROR() << "DifferenceFst: 1st argument not an acceptor"; + GetImpl()->SetProperties(kError, kError); + } + } + + template + DifferenceFst( + const Fst &fst1, const Fst &fst2, + const DifferenceFstOptions &opts) + : ComposeFst( + CreateDifferenceImplWithDifferenceOpts(fst1, fst2, opts)) { + if (!fst1.Properties(kAcceptor, true)) { + FSTERROR() << "DifferenceFst: 1st argument not an acceptor"; + GetImpl()->SetProperties(kError, kError); + } + } + + // See Fst<>::Copy() for doc. + DifferenceFst(const DifferenceFst &fst, bool safe = false) + : ComposeFst(fst, safe) {} + + // Get a copy of this DifferenceFst. See Fst<>::Copy() for further doc. + DifferenceFst *Copy(bool safe = false) const override { + return new DifferenceFst(*this, safe); + } + + private: + using Impl = internal::ComposeFstImplBase; + using ImplToFst::GetImpl; + + static std::shared_ptr CreateDifferenceImplWithCacheOpts( + const Fst &fst1, const Fst &fst2, const CacheOptions &opts) { + using RM = RhoMatcher>>; + ComplementFst cfst(fst2); + ComposeFstOptions copts( + CacheOptions(), new RM(fst1, MATCH_NONE), + new RM(cfst, MATCH_INPUT, ComplementFst::kRhoLabel)); + return CreateBase1(fst1, cfst, copts); + } + + template + static std::shared_ptr CreateDifferenceImplWithDifferenceOpts( + const Fst &fst1, const Fst &fst2, + const DifferenceFstOptions &opts) { + using RM = RhoMatcher; + ComplementFst cfst(fst2); + ComposeFstOptions copts(opts); + copts.matcher1 = new RM(fst1, MATCH_NONE, kNoLabel, MATCHER_REWRITE_ALWAYS, + opts.matcher1); + copts.matcher2 = new RM(cfst, MATCH_INPUT, ComplementFst::kRhoLabel, + MATCHER_REWRITE_ALWAYS, opts.matcher2); + return CreateBase1(fst1, cfst, copts); + } +}; + +// Specialization for DifferenceFst. +template +class StateIterator> + : public StateIterator> { + public: + explicit StateIterator(const DifferenceFst &fst) + : StateIterator>(fst) {} +}; + +// Specialization for DifferenceFst. +template +class ArcIterator> : public ArcIterator> { + public: + using StateId = typename Arc::StateId; + + ArcIterator(const DifferenceFst &fst, StateId s) + : ArcIterator>(fst, s) {} +}; + +using DifferenceOptions = ComposeOptions; + +// Useful alias when using StdArc. +using StdDifferenceFst = DifferenceFst; + +using DifferenceOptions = ComposeOptions; + +// Computes the difference between two FSAs. This version writes the difference +// to an output MutableFst. Only strings that are in the first automaton but not +// in the second are retained in the result. +// +// The first argument must be an acceptor; the second argument must be an +// unweighted, epsilon-free, deterministic acceptor. One of the arguments must +// be label-sorted. +// +// Complexity: same as Compose. +// +// Caveats: same as Compose. +template +void Difference(const Fst &ifst1, const Fst &ifst2, + MutableFst *ofst, + const DifferenceOptions &opts = DifferenceOptions()) { + using M = Matcher>; + if (opts.filter_type == AUTO_FILTER) { + CacheOptions nopts; + nopts.gc_limit = 0; // Cache only the last state for fastest copy. + *ofst = DifferenceFst(ifst1, ifst2, nopts); + } else if (opts.filter_type == SEQUENCE_FILTER) { + DifferenceFstOptions dopts; + dopts.gc_limit = 0; // Cache only the last state for fastest copy. + *ofst = DifferenceFst(ifst1, ifst2, dopts); + } else if (opts.filter_type == ALT_SEQUENCE_FILTER) { + DifferenceFstOptions> dopts; + dopts.gc_limit = 0; // Cache only the last state for fastest copy. + *ofst = DifferenceFst(ifst1, ifst2, dopts); + } else if (opts.filter_type == MATCH_FILTER) { + DifferenceFstOptions> dopts; + dopts.gc_limit = 0; // Cache only the last state for fastest copy. + *ofst = DifferenceFst(ifst1, ifst2, dopts); + } + if (opts.connect) Connect(ofst); +} + +} // namespace fst + +#endif // FST_DIFFERENCE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/disambiguate.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/disambiguate.h new file mode 100644 index 0000000000..7e3ba37c63 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/disambiguate.h @@ -0,0 +1,564 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Functions and classes to disambiguate an FST. + +#ifndef FST_DISAMBIGUATE_H_ +#define FST_DISAMBIGUATE_H_ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace fst { + +template +struct DisambiguateOptions : public DeterminizeOptions { + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + explicit DisambiguateOptions(float delta = kDelta, + Weight weight = Weight::Zero(), + StateId n = kNoStateId, Label label = 0) + : DeterminizeOptions(delta, std::move(weight), n, label, + DETERMINIZE_FUNCTIONAL) {} +}; + +namespace internal { + +// A determinization filter based on a subset element relation. The relation is +// assumed to be reflexive and symmetric. +template +class RelationDeterminizeFilter { + public: + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using FilterState = IntegerFilterState; + using StateTuple = DeterminizeStateTuple; + using Subset = typename StateTuple::Subset; + using Element = typename StateTuple::Element; + using LabelMap = std::multimap>; + + // This is needed (e.g.) to go into the gallic domain for transducers; there + // is no need to rebind the relation since its use here only depends on the + // state IDs. + template + struct rebind { + using Other = RelationDeterminizeFilter; + }; + + explicit RelationDeterminizeFilter(const Fst &fst) + : fst_(fst.Copy()), r_(new Relation()), s_(kNoStateId), head_(nullptr) {} + + // Ownership of the relation is given to this class. + RelationDeterminizeFilter(const Fst &fst, Relation *r) + : fst_(fst.Copy()), r_(r), s_(kNoStateId), head_(0) {} + + // Ownership of the relation is given to this class. + RelationDeterminizeFilter(const Fst &fst, Relation *r, + std::vector *head) + : fst_(fst.Copy()), r_(r), s_(kNoStateId), head_(head) {} + + // This is needed, e.g., to go into the gallic domain for transducers. + // Ownership of the templated filter argument is given to this class. + template + RelationDeterminizeFilter(const Fst &fst, Filter *filter) + : fst_(fst.Copy()), + r_(new Relation(filter->GetRelation())), + s_(kNoStateId), + head_(filter->GetHeadStates()) { + delete filter; + } + + // Copy constructor; the FST can be passed if it has been deep-copied. + RelationDeterminizeFilter(const RelationDeterminizeFilter &filter, + const Fst *fst = nullptr) + : fst_(fst ? fst->Copy() : filter.fst_->Copy()), + r_(new Relation(*filter.r_)), + s_(kNoStateId), + head_() {} + + FilterState Start() const { return FilterState(fst_->Start()); } + + void SetState(StateId s, const StateTuple &tuple) { + if (s_ != s) { + s_ = s; + tuple_ = &tuple; + const auto head = tuple.filter_state.GetState(); + is_final_ = fst_->Final(head) != Weight::Zero(); + if (head_) { + if (head_->size() <= s) head_->resize(s + 1, kNoStateId); + (*head_)[s] = head; + } + } + } + + // Filters transition, possibly modifying label map. Returns true if arc is + // added to label map. + bool FilterArc(const Arc &arc, const Element &src_element, + const Element &dest_element, LabelMap *label_map) const; + + // Filters super-final transition, returning new final weight. + Weight FilterFinal(const Weight final_weight, const Element &element) const { + return is_final_ ? final_weight : Weight::Zero(); + } + + static uint64 Properties(uint64 props) { + return props & ~(kIDeterministic | kODeterministic); + } + + const Relation &GetRelation() { return *r_; } + + std::vector *GetHeadStates() { return head_; } + + private: + // Pairs arc labels with state tuples with possible heads and empty subsets. + void InitLabelMap(LabelMap *label_map) const; + + std::unique_ptr> fst_; // Input FST. + std::unique_ptr r_; // Relation compatible with inv. trans. fnc. + StateId s_; // Current state. + const StateTuple *tuple_; // Current tuple. + bool is_final_; // Is the current head state final? + std::vector *head_; // Head state for a given state, + // owned by the Disambiguator. +}; + +template +bool RelationDeterminizeFilter::FilterArc( + const Arc &arc, const Element &src_element, const Element &dest_element, + LabelMap *label_map) const { + bool added = false; + if (label_map->empty()) InitLabelMap(label_map); + // Adds element to state tuple if element state is related to tuple head. + for (auto liter = label_map->lower_bound(arc.ilabel); + liter != label_map->end() && liter->first == arc.ilabel; ++liter) { + auto *dest_tuple = liter->second.dest_tuple; + const auto dest_head = dest_tuple->filter_state.GetState(); + if ((*r_)(dest_element.state_id, dest_head)) { + dest_tuple->subset.push_front(dest_element); + added = true; + } + } + return added; +} + +template +void RelationDeterminizeFilter::InitLabelMap( + LabelMap *label_map) const { + const auto src_head = tuple_->filter_state.GetState(); + Label label = kNoLabel; + StateId nextstate = kNoStateId; + for (ArcIterator> aiter(*fst_, src_head); !aiter.Done(); + aiter.Next()) { + const auto &arc = aiter.Value(); + // Continues if multiarc. + if (arc.ilabel == label && arc.nextstate == nextstate) continue; + DeterminizeArc det_arc(arc); + det_arc.dest_tuple->filter_state = FilterState(arc.nextstate); + label_map->insert(std::make_pair(arc.ilabel, det_arc)); + label = arc.ilabel; + nextstate = arc.nextstate; + } +} + +// Helper class to disambiguate an FST via Disambiguate(). +template +class Disambiguator { + public: + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + // IDs arcs with state ID and arc position. Arc position -1 indicates final + // (super-final transition). + using ArcId = std::pair; + + Disambiguator() : error_(false) {} + + void Disambiguate( + const Fst &ifst, MutableFst *ofst, + const DisambiguateOptions &opts = DisambiguateOptions()) { + VectorFst sfst(ifst); + Connect(&sfst); + ArcSort(&sfst, ArcCompare()); + PreDisambiguate(sfst, ofst, opts); + ArcSort(ofst, ArcCompare()); + FindAmbiguities(*ofst); + RemoveSplits(ofst); + MarkAmbiguities(); + RemoveAmbiguities(ofst); + if (error_) ofst->SetProperties(kError, kError); + } + + private: + // Comparison functor for comparing input labels and next states of arcs. This + // sort order facilitates the predisambiguation. + class ArcCompare { + public: + bool operator()(const Arc &arc1, const Arc &arc2) const { + return arc1.ilabel < arc2.ilabel || + (arc1.ilabel == arc2.ilabel && arc1.nextstate < arc2.nextstate); + } + + uint64 Properties(uint64 props) const { + return (props & kArcSortProperties) | kILabelSorted | + (props & kAcceptor ? kOLabelSorted : 0); + } + }; + + // Comparison functor for comparing transitions represented by their arc ID. + // This sort order facilitates ambiguity detection. + class ArcIdCompare { + public: + explicit ArcIdCompare(const std::vector &head) : head_(head) {} + + bool operator()(const ArcId &a1, const ArcId &a2) const { + // Sort first by source head state... + const auto src1 = a1.first; + const auto src2 = a2.first; + const auto head1 = head_[src1]; + const auto head2 = head_[src2]; + if (head1 < head2) return true; + if (head2 < head1) return false; + // ...then by source state... + if (src1 < src2) return true; + if (src2 < src1) return false; + // ...then by position. + return a1.second < a2.second; + } + + private: + const std::vector &head_; + }; + + // A relation that determines if two states share a common future. + class CommonFuture { + public: + using StateTable = GenericComposeStateTable; + using StateTuple = typename StateTable::StateTuple; + + // Needed for compilation with DeterminizeRelationFilter. + CommonFuture() { + FSTERROR() << "Disambiguate::CommonFuture: FST not provided"; + } + + explicit CommonFuture(const Fst &ifst) { + using M = Matcher>; + ComposeFstOptions> opts; + // Ensures composition is between acceptors. + const bool trans = ifst.Properties(kNotAcceptor, true); + const auto *fsa = + trans ? new ProjectFst(ifst, PROJECT_INPUT) : &ifst; + opts.state_table = new StateTable(*fsa, *fsa); + const ComposeFst cfst(*fsa, *fsa, opts); + std::vector coaccess; + uint64 props = 0; + SccVisitor scc_visitor(nullptr, nullptr, &coaccess, &props); + DfsVisit(cfst, &scc_visitor); + for (StateId s = 0; s < coaccess.size(); ++s) { + if (coaccess[s]) { + related_.insert(opts.state_table->Tuple(s).StatePair()); + } + } + if (trans) delete fsa; + } + + bool operator()(const StateId s1, StateId s2) const { + return related_.count(std::make_pair(s1, s2)) > 0; + } + + private: + // States s1 and s2 resp. are in this relation iff they there is a + // path from s1 to a final state that has the same label as some + // path from s2 to a final state. + std::set> related_; + }; + + using ArcIdMap = std::multimap; + + // Inserts candidate into the arc ID map. + inline void InsertCandidate(StateId s1, StateId s2, const ArcId &a1, + const ArcId &a2) { + candidates_->insert(head_[s1] > head_[s2] ? std::make_pair(a1, a2) + : std::make_pair(a2, a1)); + } + + // Returns the arc corresponding to ArcId a. + static Arc GetArc(const Fst &fst, ArcId aid) { + if (aid.second == -1) { // Returns super-final transition. + return Arc(kNoLabel, kNoLabel, fst.Final(aid.first), kNoStateId); + } else { + ArcIterator> aiter(fst, aid.first); + aiter.Seek(aid.second); + return aiter.Value(); + } + } + + // Outputs an equivalent FST whose states are subsets of states that have a + // future path in common. + void PreDisambiguate(const ExpandedFst &ifst, MutableFst *ofst, + const DisambiguateOptions &opts); + + // Finds transitions that are ambiguous candidates in the result of + // PreDisambiguate. + void FindAmbiguities(const ExpandedFst &fst); + + // Finds transition pairs that are ambiguous candidates from two specified + // source states. + void FindAmbiguousPairs(const ExpandedFst &fst, StateId s1, StateId s2); + + // Marks ambiguous transitions to be removed. + void MarkAmbiguities(); + + // Deletes spurious ambiguous transitions (due to quantization). + void RemoveSplits(MutableFst *ofst); + + // Deletes actual ambiguous transitions. + void RemoveAmbiguities(MutableFst *ofst); + + // States s1 and s2 are in this relation iff there is a path from the initial + // state to s1 that has the same label as some path from the initial state to + // s2. We store only state pairs s1, s2 such that s1 <= s2. + std::set> coreachable_; + + // Queue of disambiguation-related states to be processed. We store only + // state pairs s1, s2 such that s1 <= s2. + std::list> queue_; + + // Head state in the pre-disambiguation for a given state. + std::vector head_; + + // Maps from a candidate ambiguous arc A to each ambiguous candidate arc B + // with the same label and destination state as A, whose source state s' is + // coreachable with the source state s of A, and for which head(s') < head(s). + std::unique_ptr candidates_; + + // Set of ambiguous transitions to be removed. + std::set ambiguous_; + + // States to merge due to quantization issues. + std::unique_ptr> merge_; + // Marks error condition. + bool error_; + + Disambiguator(const Disambiguator &) = delete; + Disambiguator &operator=(const Disambiguator &) = delete; +}; + +template +void Disambiguator::PreDisambiguate(const ExpandedFst &ifst, + MutableFst *ofst, + const DisambiguateOptions &opts) { + using CommonDivisor = DefaultCommonDivisor; + using Filter = RelationDeterminizeFilter; + // Subset elements with states s1 and s2 (resp.) are in this relation iff they + // there is a path from s1 to a final state that has the same label as some + // path from s2 to a final state. + auto *common_future = new CommonFuture(ifst); + DeterminizeFstOptions nopts; + nopts.delta = opts.delta; + nopts.subsequential_label = opts.subsequential_label; + nopts.filter = new Filter(ifst, common_future, &head_); + // The filter takes ownership of 'common_future', and determinization takes + // ownership of the filter itself. + nopts.gc_limit = 0; // Cache only the last state for fastest copy. + if (opts.weight_threshold != Weight::Zero() || + opts.state_threshold != kNoStateId) { + /* TODO(riley): fails regression test; understand why + if (ifst.Properties(kAcceptor, true)) { + std::vector idistance, odistance; + ShortestDistance(ifst, &idistance, true); + DeterminizeFst dfst(ifst, &idistance, &odistance, nopts); + PruneOptions< Arc, AnyArcFilter> popts(opts.weight_threshold, + opts.state_threshold, + AnyArcFilter(), + &odistance); + Prune(dfst, ofst, popts); + } else */ { + *ofst = DeterminizeFst(ifst, nopts); + Prune(ofst, opts.weight_threshold, opts.state_threshold); + } + } else { + *ofst = DeterminizeFst(ifst, nopts); + } + head_.resize(ofst->NumStates(), kNoStateId); +} + +template +void Disambiguator::FindAmbiguities(const ExpandedFst &fst) { + if (fst.Start() == kNoStateId) return; + candidates_.reset(new ArcIdMap(ArcIdCompare(head_))); + const auto start_pr = std::make_pair(fst.Start(), fst.Start()); + coreachable_.insert(start_pr); + queue_.push_back(start_pr); + while (!queue_.empty()) { + const auto &pr = queue_.front(); + const auto s1 = pr.first; + const auto s2 = pr.second; + queue_.pop_front(); + FindAmbiguousPairs(fst, s1, s2); + } +} + +template +void Disambiguator::FindAmbiguousPairs(const ExpandedFst &fst, + StateId s1, StateId s2) { + if (fst.NumArcs(s2) > fst.NumArcs(s1)) FindAmbiguousPairs(fst, s2, s1); + SortedMatcher> matcher(fst, MATCH_INPUT); + matcher.SetState(s2); + for (ArcIterator> aiter(fst, s1); !aiter.Done(); aiter.Next()) { + const auto &arc1 = aiter.Value(); + const ArcId a1(s1, aiter.Position()); + if (matcher.Find(arc1.ilabel)) { + for (; !matcher.Done(); matcher.Next()) { + const auto &arc2 = matcher.Value(); + // Continues on implicit epsilon match. + if (arc2.ilabel == kNoLabel) continue; + const ArcId a2(s2, matcher.Position()); + // Actual transition is ambiguous. + if (s1 != s2 && arc1.nextstate == arc2.nextstate) { + InsertCandidate(s1, s2, a1, a2); + } + const auto spr = arc1.nextstate <= arc2.nextstate + ? std::make_pair(arc1.nextstate, arc2.nextstate) + : std::make_pair(arc2.nextstate, arc1.nextstate); + // Not already marked as coreachable? + if (coreachable_.insert(spr).second) { + // Only possible if state split by quantization issues. + if (spr.first != spr.second && + head_[spr.first] == head_[spr.second]) { + if (!merge_) { + merge_.reset(new UnionFind(fst.NumStates(), kNoStateId)); + merge_->MakeAllSet(fst.NumStates()); + } + merge_->Union(spr.first, spr.second); + } else { + queue_.push_back(spr); + } + } + } + } + } + // Super-final transition is ambiguous. + if (s1 != s2 && fst.Final(s1) != Weight::Zero() && + fst.Final(s2) != Weight::Zero()) { + const ArcId a1(s1, -1); + const ArcId a2(s2, -1); + InsertCandidate(s1, s2, a1, a2); + } +} + +template +void Disambiguator::MarkAmbiguities() { + if (!candidates_) return; + for (auto it = candidates_->begin(); it != candidates_->end(); ++it) { + const auto a = it->first; + const auto b = it->second; + // If b is not to be removed, then a is. + if (ambiguous_.count(b) == 0) ambiguous_.insert(a); + } + coreachable_.clear(); + candidates_.reset(); +} + +template +void Disambiguator::RemoveSplits(MutableFst *ofst) { + if (!merge_) return; + // Merges split states to remove spurious ambiguities. + for (StateIterator> siter(*ofst); !siter.Done(); + siter.Next()) { + for (MutableArcIterator> aiter(ofst, siter.Value()); + !aiter.Done(); aiter.Next()) { + auto arc = aiter.Value(); + const auto nextstate = merge_->FindSet(arc.nextstate); + if (nextstate != arc.nextstate) { + arc.nextstate = nextstate; + aiter.SetValue(arc); + } + } + } + // Repeats search for actual ambiguities on modified FST. + coreachable_.clear(); + merge_.reset(); + candidates_.reset(); + FindAmbiguities(*ofst); + if (merge_) { // Shouldn't get here; sanity test. + FSTERROR() << "Disambiguate: Unable to remove spurious ambiguities"; + error_ = true; + return; + } +} + +template +void Disambiguator::RemoveAmbiguities(MutableFst *ofst) { + if (ambiguous_.empty()) return; + // Adds dead state to redirect ambiguous transitions to be removed. + const auto dead = ofst->AddState(); + for (auto it = ambiguous_.begin(); it != ambiguous_.end(); ++it) { + const auto pos = it->second; + if (pos >= 0) { // Actual transition. + MutableArcIterator> aiter(ofst, it->first); + aiter.Seek(pos); + auto arc = aiter.Value(); + arc.nextstate = dead; + aiter.SetValue(arc); + } else { // Super-final transition. + ofst->SetFinal(it->first, Weight::Zero()); + } + } + Connect(ofst); + ambiguous_.clear(); +} + +} // namespace internal + +// Disambiguates a weighted FST. This version writes the disambiguated FST to an +// output MutableFst. The result will be an equivalent FST that has the +// property that there are not two distinct paths from the initial state to a +// final state with the same input labeling. +// +// The weights must be (weakly) left divisible (valid for Tropical and +// LogWeight). +// +// Complexity: +// +// Disambiguable: exponential (polynomial in the size of the output). +// Non-disambiguable: does not terminate. +// +// The disambiguable transducers include all automata and functional transducers +// that are unweighted or that are acyclic or that are unambiguous. +// +// For more information, see: +// +// Mohri, M. and Riley, M. 2015. On the disambiguation of weighted automata. +// In CIAA, pages 263-278. +template +void Disambiguate( + const Fst &ifst, MutableFst *ofst, + const DisambiguateOptions &opts = DisambiguateOptions()) { + internal::Disambiguator disambiguator; + disambiguator.Disambiguate(ifst, ofst, opts); +} + +} // namespace fst + +#endif // FST_DISAMBIGUATE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/edit-fst.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/edit-fst.h new file mode 100644 index 0000000000..e7bdfd6183 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/edit-fst.h @@ -0,0 +1,702 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// An FST implementation that allows non-destructive edit operations on an +// existing FST. +// +// The EditFst class enables non-destructive edit operations on a wrapped +// ExpandedFst. The implementation uses copy-on-write semantics at the node +// level: if a user has an underlying fst on which he or she wants to perform a +// relatively small number of edits (read: mutations), then this implementation +// will copy the edited node to an internal MutableFst and perform any edits in +// situ on that copied node. This class supports all the methods of MutableFst +// except for DeleteStates(const std::vector &); thus, new nodes may +// also be +// added, and one may add transitions from existing nodes of the wrapped fst to +// new nodes. +// +// N.B.: The documentation for Fst::Copy(true) says that its behavior is +// undefined if invoked on an fst that has already been accessed. This class +// requires that the Fst implementation it wraps provides consistent, reliable +// behavior when its Copy(true) method is invoked, where consistent means +// the graph structure, graph properties and state numbering and do not change. +// VectorFst and CompactFst, for example, are both well-behaved in this regard. + +#ifndef FST_EDIT_FST_H_ +#define FST_EDIT_FST_H_ + +#include +#include +#include + +#include + +#include + + +namespace fst { +namespace internal { + +// The EditFstData class is a container for all mutable data for EditFstImpl; +// also, this class provides most of the actual implementation of what EditFst +// does (that is, most of EditFstImpl's methods delegate to methods in this, the +// EditFstData class). Instances of this class are reference-counted and can be +// shared between otherwise independent EditFstImpl instances. This scheme +// allows EditFstImpl to implement the thread-safe, copy-on-write semantics +// required by Fst::Copy(true). +// +// template parameters: +// A the type of arc to use +// WrappedFstT the type of fst wrapped by the EditFst instance that +// this EditFstData instance is backing +// MutableFstT the type of mutable fst to use internally for edited states; +// crucially, MutableFstT::Copy(false) *must* yield an fst that is +// thread-safe for reading (VectorFst, for example, has this property) +template , + typename MutableFstT = VectorFst> +class EditFstData { + public: + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + EditFstData() : num_new_states_(0) {} + + EditFstData(const EditFstData &other) + : edits_(other.edits_), + external_to_internal_ids_(other.external_to_internal_ids_), + edited_final_weights_(other.edited_final_weights_), + num_new_states_(other.num_new_states_) {} + + ~EditFstData() {} + + static EditFstData *Read( + std::istream &strm, const FstReadOptions &opts); + + bool Write(std::ostream &strm, const FstWriteOptions &opts) const { + // Serialize all private data members of this class. + FstWriteOptions edits_opts(opts); + edits_opts.write_header = true; // Force writing contained header. + edits_.Write(strm, edits_opts); + WriteType(strm, external_to_internal_ids_); + WriteType(strm, edited_final_weights_); + WriteType(strm, num_new_states_); + if (!strm) { + LOG(ERROR) << "EditFstData::Write: Write failed: " << opts.source; + return false; + } + return true; + } + + StateId NumNewStates() const { return num_new_states_; } + + // accessor methods for the fst holding edited states + StateId EditedStart() const { return edits_.Start(); } + + Weight Final(StateId s, const WrappedFstT *wrapped) const { + auto final_weight_it = GetFinalWeightIterator(s); + if (final_weight_it == NotInFinalWeightMap()) { + auto it = GetEditedIdMapIterator(s); + return it == NotInEditedMap() ? wrapped->Final(s) + : edits_.Final(it->second); + } else { + return final_weight_it->second; + } + } + + size_t NumArcs(StateId s, const WrappedFstT *wrapped) const { + auto it = GetEditedIdMapIterator(s); + return it == NotInEditedMap() ? wrapped->NumArcs(s) + : edits_.NumArcs(it->second); + } + + size_t NumInputEpsilons(StateId s, const WrappedFstT *wrapped) const { + auto it = GetEditedIdMapIterator(s); + return it == NotInEditedMap() ? wrapped->NumInputEpsilons(s) + : edits_.NumInputEpsilons(it->second); + } + + size_t NumOutputEpsilons(StateId s, const WrappedFstT *wrapped) const { + auto it = GetEditedIdMapIterator(s); + return it == NotInEditedMap() ? wrapped->NumOutputEpsilons(s) + : edits_.NumOutputEpsilons(it->second); + } + + void SetEditedProperties(uint64 props, uint64 mask) { + edits_.SetProperties(props, mask); + } + + // Non-const MutableFst operations. + + // Sets the start state for this FST. + void SetStart(StateId s) { edits_.SetStart(s); } + + // Sets the final state for this FST. + Weight SetFinal(StateId s, Weight w, const WrappedFstT *wrapped) { + Weight old_weight = Final(s, wrapped); + auto it = GetEditedIdMapIterator(s); + // If we haven't already edited state s, don't add it to edited_ (which can + // be expensive if s has many transitions); just use the + // edited_final_weights_ map. + if (it == NotInEditedMap()) { + edited_final_weights_[s] = w; + } else { + edits_.SetFinal(GetEditableInternalId(s, wrapped), w); + } + return old_weight; + } + + // Adds a new state to this FST, initially with no arcs. + StateId AddState(StateId curr_num_states) { + StateId internal_state_id = edits_.AddState(); + StateId external_state_id = curr_num_states; + external_to_internal_ids_[external_state_id] = internal_state_id; + num_new_states_++; + return external_state_id; + } + + // Adds the specified arc to the specified state of this FST. + const Arc *AddArc(StateId s, const Arc &arc, const WrappedFstT *wrapped) { + const auto internal_id = GetEditableInternalId(s, wrapped); + const auto num_arcs = edits_.NumArcs(internal_id); + ArcIterator arc_it(edits_, internal_id); + const Arc *prev_arc = nullptr; + if (num_arcs > 0) { + // grab the final arc associated with this state in edits_ + arc_it.Seek(num_arcs - 1); + prev_arc = &(arc_it.Value()); + } + edits_.AddArc(internal_id, arc); + return prev_arc; + } + + void DeleteStates() { + edits_.DeleteStates(); + num_new_states_ = 0; + external_to_internal_ids_.clear(); + edited_final_weights_.clear(); + } + + // Removes all but the first n outgoing arcs of the specified state. + void DeleteArcs(StateId s, size_t n, const WrappedFstT *wrapped) { + edits_.DeleteArcs(GetEditableInternalId(s, wrapped), n); + } + + // Removes all outgoing arcs from the specified state. + void DeleteArcs(StateId s, const WrappedFstT *wrapped) { + edits_.DeleteArcs(GetEditableInternalId(s, wrapped)); + } + + // End methods for non-const MutableFst operations. + + // Provides information for the generic arc iterator. + void InitArcIterator(StateId s, ArcIteratorData *data, + const WrappedFstT *wrapped) const { + auto id_map_it = GetEditedIdMapIterator(s); + if (id_map_it == NotInEditedMap()) { + VLOG(3) << "EditFstData::InitArcIterator: iterating on state " << s + << " of original fst"; + wrapped->InitArcIterator(s, data); + } else { + VLOG(2) << "EditFstData::InitArcIterator: iterating on edited state " << s + << " (internal state id: " << id_map_it->second << ")"; + edits_.InitArcIterator(id_map_it->second, data); + } + } + + // Provides information for the generic mutable arc iterator. + void InitMutableArcIterator(StateId s, MutableArcIteratorData *data, + const WrappedFstT *wrapped) { + data->base = new MutableArcIterator( + &edits_, GetEditableInternalId(s, wrapped)); + } + + // Prints out the map from external to internal state id's (for debugging + // purposes). + void PrintMap() { + for (auto map_it = external_to_internal_ids_.begin(); + map_it != NotInEditedMap(); ++map_it) { + LOG(INFO) << "(external,internal)=(" << map_it->first << "," + << map_it->second << ")"; + } + } + + private: + // Returns the iterator of the map from external to internal state id's + // of edits_ for the specified external state id. + typename std::unordered_map::const_iterator + GetEditedIdMapIterator(StateId s) const { + return external_to_internal_ids_.find(s); + } + + typename std::unordered_map::const_iterator + NotInEditedMap() const { + return external_to_internal_ids_.end(); + } + + typename std::unordered_map::const_iterator + GetFinalWeightIterator(StateId s) const { + return edited_final_weights_.find(s); + } + + typename std::unordered_map::const_iterator + NotInFinalWeightMap() const { + return edited_final_weights_.end(); + } + + // Returns the internal state ID of the specified external ID if the state has + // already been made editable, or else copies the state from wrapped_ to + // edits_ and returns the state id of the newly editable state in edits_. + StateId GetEditableInternalId(StateId s, const WrappedFstT *wrapped) { + auto id_map_it = GetEditedIdMapIterator(s); + if (id_map_it == NotInEditedMap()) { + StateId new_internal_id = edits_.AddState(); + VLOG(2) << "EditFstData::GetEditableInternalId: editing state " << s + << " of original fst; new internal state id:" << new_internal_id; + external_to_internal_ids_[s] = new_internal_id; + for (ArcIterator> arc_iterator(*wrapped, s); + !arc_iterator.Done(); arc_iterator.Next()) { + edits_.AddArc(new_internal_id, arc_iterator.Value()); + } + // Copies the final weight. + auto final_weight_it = GetFinalWeightIterator(s); + if (final_weight_it == NotInFinalWeightMap()) { + edits_.SetFinal(new_internal_id, wrapped->Final(s)); + } else { + edits_.SetFinal(new_internal_id, final_weight_it->second); + edited_final_weights_.erase(s); + } + return new_internal_id; + } else { + return id_map_it->second; + } + } + + // A mutable FST (by default, a VectorFst) to contain new states, and/or + // copies of states from a wrapped ExpandedFst that have been modified in + // some way. + MutableFstT edits_; + // A mapping from external state IDs to the internal IDs of states that + // appear in edits_. + std::unordered_map external_to_internal_ids_; + // A mapping from external state IDs to final state weights assigned to + // those states. The states in this map are *only* those whose final weight + // has been modified; if any other part of the state has been modified, + // the entire state is copied to edits_, and all modifications reside there. + std::unordered_map edited_final_weights_; + // The number of new states added to this mutable fst impl, which is <= the + // number of states in edits_ (since edits_ contains both edited *and* new + // states). + StateId num_new_states_; +}; + +// EditFstData method implementations: just the Read method. +template +EditFstData * +EditFstData::Read(std::istream &strm, + const FstReadOptions &opts) { + auto *data = new EditFstData(); + // next read in MutabelFstT machine that stores edits + FstReadOptions edits_opts(opts); + // Contained header was written out, so read it in. + edits_opts.header = nullptr; + + // Because our internal representation of edited states is a solid object + // of type MutableFstT (defaults to VectorFst) and not a pointer, + // and because the static Read method allocates a new object on the heap, + // we need to call Read, check if there was a failure, use + // MutableFstT::operator= to assign the object (not the pointer) to the + // edits_ data member (which will increase the ref count by 1 on the impl) + // and, finally, delete the heap-allocated object. + std::unique_ptr edits(MutableFstT::Read(strm, edits_opts)); + if (!edits) return nullptr; + data->edits_ = *edits; + edits.reset(); + // Finally, reads in rest of private data members. + ReadType(strm, &data->external_to_internal_ids_); + ReadType(strm, &data->edited_final_weights_); + ReadType(strm, &data->num_new_states_); + if (!strm) { + LOG(ERROR) << "EditFst::Read: read failed: " << opts.source; + return nullptr; + } + return data; +} + +// This class enables non-destructive edit operations on a wrapped ExpandedFst. +// The implementation uses copy-on-write semantics at the node level: if a user +// has an underlying fst on which he or she wants to perform a relatively small +// number of edits (read: mutations), then this implementation will copy the +// edited node to an internal MutableFst and perform any edits in situ on that +// copied node. This class supports all the methods of MutableFst except for +// DeleteStates(const std::vector &); thus, new nodes may also be +// added, and +// one may add transitions from existing nodes of the wrapped fst to new nodes. +// +// template parameters: +// A the type of arc to use +// WrappedFstT the type of fst wrapped by the EditFst instance that +// this EditFstImpl instance is backing +// MutableFstT the type of mutable fst to use internally for edited states; +// crucially, MutableFstT::Copy(false) *must* yield an fst that is +// thread-safe for reading (VectorFst, for example, has this property) +template , + typename MutableFstT = VectorFst> +class EditFstImpl : public FstImpl { + public: + using Arc = A; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using FstImpl::SetProperties; + using FstImpl::SetInputSymbols; + using FstImpl::SetOutputSymbols; + using FstImpl::WriteHeader; + + // Constructs an editable FST implementation with no states. Effectively, this + // initially-empty fst will in every way mimic the behavior of a + // VectorFst---more precisely, a VectorFstImpl instance---but with slightly + // slower performance (by a constant factor), due to the fact that + // this class maintains a mapping between external state id's and + // their internal equivalents. + EditFstImpl() : wrapped_(new MutableFstT()) { + FstImpl::SetType("edit"); + InheritPropertiesFromWrapped(); + data_ = std::make_shared>(); + } + + // Wraps the specified ExpandedFst. This constructor requires that the + // specified Fst is an ExpandedFst instance. This requirement is only enforced + // at runtime. (See below for the reason.) + // + // This library uses the pointer-to-implementation or "PIMPL" design pattern. + // In particular, to make it convenient to bind an implementation class to its + // interface, there are a pair of template "binder" classes, one for immutable + // and one for mutable fst's (ImplToFst and ImplToMutableFst, respectively). + // As it happens, the API for the ImplToMutableFst class requires that + // the implementation class--the template parameter "I"--have a constructor + // taking a const Fst reference. Accordingly, the constructor here must + // perform a static_cast to the WrappedFstT type required by EditFst and + // therefore EditFstImpl. + explicit EditFstImpl(const Fst &wrapped) + : wrapped_(static_cast(wrapped.Copy())) { + FstImpl::SetType("edit"); + data_ = std::make_shared>(); + // have edits_ inherit all properties from wrapped_ + data_->SetEditedProperties(wrapped_->Properties(kFstProperties, false), + kFstProperties); + InheritPropertiesFromWrapped(); + } + + // A copy constructor for this implementation class, used to implement + // the Copy() method of the Fst interface. + EditFstImpl(const EditFstImpl &impl) + : FstImpl(), + wrapped_(static_cast(impl.wrapped_->Copy(true))), + data_(impl.data_) { + SetProperties(impl.Properties()); + } + + // const Fst/ExpandedFst operations, declared in the Fst and ExpandedFst + // interfaces + StateId Start() const { + const auto edited_start = data_->EditedStart(); + return edited_start == kNoStateId ? wrapped_->Start() : edited_start; + } + + Weight Final(StateId s) const { return data_->Final(s, wrapped_.get()); } + + size_t NumArcs(StateId s) const { return data_->NumArcs(s, wrapped_.get()); } + + size_t NumInputEpsilons(StateId s) const { + return data_->NumInputEpsilons(s, wrapped_.get()); + } + + size_t NumOutputEpsilons(StateId s) const { + return data_->NumOutputEpsilons(s, wrapped_.get()); + } + + StateId NumStates() const { + return wrapped_->NumStates() + data_->NumNewStates(); + } + + static EditFstImpl *Read( + std::istream &strm, const FstReadOptions &opts); + + bool Write(std::ostream &strm, const FstWriteOptions &opts) const { + FstHeader hdr; + hdr.SetStart(Start()); + hdr.SetNumStates(NumStates()); + FstWriteOptions header_opts(opts); + // Allows the contained FST to hold any symbols. + header_opts.write_isymbols = false; + header_opts.write_osymbols = false; + WriteHeader(strm, header_opts, kFileVersion, &hdr); + // First, serializes the wrapped FST to stream. + FstWriteOptions wrapped_opts(opts); + // Forcse writing the contained header. + wrapped_opts.write_header = true; + wrapped_->Write(strm, wrapped_opts); + data_->Write(strm, opts); + strm.flush(); + if (!strm) { + LOG(ERROR) << "EditFst::Write: Write failed: " << opts.source; + return false; + } + return true; + } + + // Sets the start state for this FST. + void SetStart(StateId s) { + MutateCheck(); + data_->SetStart(s); + SetProperties(SetStartProperties(FstImpl::Properties())); + } + + // Sets the final state for this fst. + void SetFinal(StateId s, Weight weight) { + MutateCheck(); + Weight old_weight = data_->SetFinal(s, weight, wrapped_.get()); + SetProperties( + SetFinalProperties(FstImpl::Properties(), old_weight, weight)); + } + + // Adds a new state to this fst, initially with no arcs. + StateId AddState() { + MutateCheck(); + SetProperties(AddStateProperties(FstImpl::Properties())); + return data_->AddState(NumStates()); + } + + // Adds the specified arc to the specified state of this fst. + void AddArc(StateId s, const Arc &arc) { + MutateCheck(); + const auto *prev_arc = data_->AddArc(s, arc, wrapped_.get()); + SetProperties( + AddArcProperties(FstImpl::Properties(), s, arc, prev_arc)); + } + + void DeleteStates(const std::vector &dstates) { + FSTERROR() << ": EditFstImpl::DeleteStates(const std::vector&): " + << " not implemented"; + SetProperties(kError, kError); + } + + // Deletes all states in this fst. + void DeleteStates(); + + // Removes all but the first n outgoing arcs of the specified state. + void DeleteArcs(StateId s, size_t n) { + MutateCheck(); + data_->DeleteArcs(s, n, wrapped_.get()); + SetProperties(DeleteArcsProperties(FstImpl::Properties())); + } + + // Removes all outgoing arcs from the specified state. + void DeleteArcs(StateId s) { + MutateCheck(); + data_->DeleteArcs(s, wrapped_.get()); + SetProperties(DeleteArcsProperties(FstImpl::Properties())); + } + + void ReserveStates(StateId s) {} + + void ReserveArcs(StateId s, size_t n) {} + + // Ends non-const MutableFst operations. + + // Provides information for the generic state iterator. + void InitStateIterator(StateIteratorData *data) const { + data->base = nullptr; + data->nstates = NumStates(); + } + + // Provides information for the generic arc iterator. + void InitArcIterator(StateId s, ArcIteratorData *data) const { + data_->InitArcIterator(s, data, wrapped_.get()); + } + + // Provides information for the generic mutable arc iterator. + void InitMutableArcIterator(StateId s, MutableArcIteratorData *data) { + MutateCheck(); + data_->InitMutableArcIterator(s, data, wrapped_.get()); + } + + private: + // Properties always true of this FST class. + static constexpr uint64 kStaticProperties = kExpanded | kMutable; + // Current file format version. + static constexpr int kFileVersion = 2; + // Minimum file format version supported + static constexpr int kMinFileVersion = 2; + + // Causes this FST to inherit all the properties from its wrapped FST, except + // for the two properties that always apply to EditFst instances: kExpanded + // and kMutable. + void InheritPropertiesFromWrapped() { + SetProperties(wrapped_->Properties(kCopyProperties, false) | + kStaticProperties); + SetInputSymbols(wrapped_->InputSymbols()); + SetOutputSymbols(wrapped_->OutputSymbols()); + } + + // This method ensures that any operations that alter the mutable data + // portion of this EditFstImpl cause the data_ member to be copied when its + // reference count is greater than 1. Note that this method is distinct from + // MutableFst::Mutate, which gets invoked whenever one of the basic mutation + // methods defined in MutableFst is invoked, such as SetInputSymbols. + // The MutateCheck here in EditFstImpl is invoked whenever one of the + // mutating methods specifically related to the types of edits provided + // by EditFst is performed, such as changing an arc of an existing state + // of the wrapped fst via a MutableArcIterator, or adding a new state via + // AddState(). + void MutateCheck() { + if (!data_.unique()) { + data_ = + std::make_shared>(*data_); + } + } + + // The FST that this FST wraps. The purpose of this class is to enable + // non-destructive edits on this wrapped FST. + std::unique_ptr wrapped_; + // The mutable data for this EditFst instance, with delegates for all the + // methods that can mutate data. + std::shared_ptr> data_; +}; + +template +constexpr uint64 EditFstImpl::kStaticProperties; + +template +constexpr int EditFstImpl::kFileVersion; + +template +constexpr int EditFstImpl::kMinFileVersion; + +template +inline void EditFstImpl::DeleteStates() { + data_->DeleteStates(); + // we are deleting all states, so just forget about pointer to wrapped_ + // and do what default constructor does: set wrapped_ to a new VectorFst + wrapped_.reset(new MutableFstT()); + const auto new_props = + DeleteAllStatesProperties(FstImpl::Properties(), kStaticProperties); + FstImpl::SetProperties(new_props); +} + +template +EditFstImpl * +EditFstImpl::Read(std::istream &strm, + const FstReadOptions &opts) { + auto *impl = new EditFstImpl(); + FstHeader hdr; + if (!impl->ReadHeader(strm, opts, kMinFileVersion, &hdr)) return nullptr; + impl->SetStart(hdr.Start()); + // Reads in wrapped FST. + FstReadOptions wrapped_opts(opts); + // Contained header was written out, so reads it in too. + wrapped_opts.header = nullptr; + std::unique_ptr> wrapped_fst(Fst::Read(strm, wrapped_opts)); + if (!wrapped_fst) return nullptr; + impl->wrapped_.reset(static_cast(wrapped_fst.release())); + impl->data_ = std::shared_ptr>( + EditFstData::Read(strm, opts)); + if (!impl->data_) return nullptr; + return impl; +} + +} // namespace internal + +// Concrete, editable FST. This class attaches interface to implementation. +template , + typename MutableFstT = VectorFst> +class EditFst : public ImplToMutableFst< + internal::EditFstImpl> { + public: + using Arc = A; + using StateId = typename Arc::StateId; + + using Impl = internal::EditFstImpl; + + friend class MutableArcIterator>; + + EditFst() : ImplToMutableFst(std::make_shared()) {} + + explicit EditFst(const Fst &fst) + : ImplToMutableFst(std::make_shared(fst)) {} + + explicit EditFst(const WrappedFstT &fst) + : ImplToMutableFst(std::make_shared(fst)) {} + + // See Fst<>::Copy() for doc. + EditFst(const EditFst &fst, bool safe = false) + : ImplToMutableFst(fst, safe) {} + + ~EditFst() override {} + + // Gets a copy of this EditFst. See Fst<>::Copy() for further doc. + EditFst *Copy( + bool safe = false) const override { + return new EditFst(*this, safe); + } + + EditFst &operator=( + const EditFst &fst) { + SetImpl(fst.GetSharedImpl()); + return *this; + } + + EditFst &operator=( + const Fst &fst) override { + SetImpl(std::make_shared(fst)); + return *this; + } + + // Reads an EditFst from an input stream, returning nullptr on error. + static EditFst *Read( + std::istream &strm, const FstReadOptions &opts) { + auto *impl = Impl::Read(strm, opts); + return impl ? new EditFst(std::shared_ptr(impl)) : nullptr; + } + + // Reads an EditFst from a file, returning nullptr on error. If the filename + // argument is an empty string, it reads from standard input. + static EditFst *Read(const string &filename) { + auto *impl = ImplToExpandedFst>::Read(filename); + return impl ? new EditFst( + std::shared_ptr(impl)) + : nullptr; + } + + bool Write(std::ostream &strm, const FstWriteOptions &opts) const override { + return GetImpl()->Write(strm, opts); + } + + bool Write(const string &filename) const override { + return Fst::WriteFile(filename); + } + + void InitStateIterator(StateIteratorData *data) const override { + GetImpl()->InitStateIterator(data); + } + + void InitArcIterator(StateId s, ArcIteratorData *data) const override { + GetImpl()->InitArcIterator(s, data); + } + + void InitMutableArcIterator(StateId s, + MutableArcIteratorData *data) override { + GetMutableImpl()->InitMutableArcIterator(s, data); + } + + private: + explicit EditFst(std::shared_ptr impl) : ImplToMutableFst(impl) {} + + using ImplToFst>::GetImpl; + using ImplToFst>::GetMutableImpl; + using ImplToFst>::SetImpl; +}; + +} // namespace fst + +#endif // FST_EDIT_FST_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/encode.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/encode.h new file mode 100644 index 0000000000..f251bbfcf4 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/encode.h @@ -0,0 +1,556 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Class to encode and decode an FST. + +#ifndef FST_ENCODE_H_ +#define FST_ENCODE_H_ + +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include + + +namespace fst { + +enum EncodeType { ENCODE = 1, DECODE = 2 }; + +static constexpr uint32 kEncodeLabels = 0x0001; +static constexpr uint32 kEncodeWeights = 0x0002; +static constexpr uint32 kEncodeFlags = 0x0003; + +namespace internal { + +static constexpr uint32 kEncodeHasISymbols = 0x0004; +static constexpr uint32 kEncodeHasOSymbols = 0x0008; + +// Identifies stream data as an encode table (and its endianity) +static const int32 kEncodeMagicNumber = 2129983209; + +// The following class encapsulates implementation details for the encoding and +// decoding of label/weight tuples used for encoding and decoding of FSTs. The +// EncodeTable is bidirectional. I.e, it stores both the Tuple of encode labels +// and weights to a unique label, and the reverse. +template +class EncodeTable { + public: + using Label = typename Arc::Label; + using Weight = typename Arc::Weight; + + // Encoded data consists of arc input/output labels and arc weight. + struct Tuple { + Tuple() {} + + Tuple(Label ilabel_, Label olabel_, Weight weight_) + : ilabel(ilabel_), olabel(olabel_), weight(std::move(weight_)) {} + + Tuple(const Tuple &tuple) + : ilabel(tuple.ilabel), + olabel(tuple.olabel), + weight(std::move(tuple.weight)) {} + + Label ilabel; + Label olabel; + Weight weight; + }; + + // Comparison object for hashing EncodeTable Tuple(s). + class TupleEqual { + public: + bool operator()(const Tuple *x, const Tuple *y) const { + return (x->ilabel == y->ilabel && x->olabel == y->olabel && + x->weight == y->weight); + } + }; + + // Hash function for EncodeTabe Tuples. Based on the encode flags + // we either hash the labels, weights or combination of them. + class TupleKey { + public: + TupleKey() : encode_flags_(kEncodeLabels | kEncodeWeights) {} + + TupleKey(const TupleKey &key) : encode_flags_(key.encode_flags_) {} + + explicit TupleKey(uint32 encode_flags) : encode_flags_(encode_flags) {} + + size_t operator()(const Tuple *x) const { + size_t hash = x->ilabel; + static constexpr int lshift = 5; + static constexpr int rshift = CHAR_BIT * sizeof(size_t) - 5; + if (encode_flags_ & kEncodeLabels) { + hash = hash << lshift ^ hash >> rshift ^ x->olabel; + } + if (encode_flags_ & kEncodeWeights) { + hash = hash << lshift ^ hash >> rshift ^ x->weight.Hash(); + } + return hash; + } + + private: + int32 encode_flags_; + }; + + explicit EncodeTable(uint32 encode_flags) + : flags_(encode_flags), encode_hash_(1024, TupleKey(encode_flags)) {} + + using EncodeHash = std::unordered_map; + + // Given an arc, encodes either input/output labels or input/costs or both. + Label Encode(const Arc &arc) { + std::unique_ptr tuple( + new Tuple(arc.ilabel, flags_ & kEncodeLabels ? arc.olabel : 0, + flags_ & kEncodeWeights ? arc.weight : Weight::One())); + auto insert_result = encode_hash_.insert( + std::make_pair(tuple.get(), encode_tuples_.size() + 1)); + if (insert_result.second) encode_tuples_.push_back(std::move(tuple)); + return insert_result.first->second; + } + + // Given an arc, looks up its encoded label or returns kNoLabel if not found. + Label GetLabel(const Arc &arc) const { + const Tuple tuple(arc.ilabel, flags_ & kEncodeLabels ? arc.olabel : 0, + flags_ & kEncodeWeights ? arc.weight : Weight::One()); + auto it = encode_hash_.find(&tuple); + return (it == encode_hash_.end()) ? kNoLabel : it->second; + } + + // Given an encoded arc label, decodes back to input/output labels and costs. + const Tuple *Decode(Label key) const { + if (key < 1 || key > encode_tuples_.size()) { + LOG(ERROR) << "EncodeTable::Decode: Unknown decode key: " << key; + return nullptr; + } + return encode_tuples_[key - 1].get(); + } + + size_t Size() const { return encode_tuples_.size(); } + + bool Write(std::ostream &strm, const string &source) const; + + static EncodeTable *Read(std::istream &strm, const string &source); + + uint32 Flags() const { return flags_ & kEncodeFlags; } + + const SymbolTable *InputSymbols() const { return isymbols_.get(); } + + const SymbolTable *OutputSymbols() const { return osymbols_.get(); } + + void SetInputSymbols(const SymbolTable *syms) { + if (syms) { + isymbols_.reset(syms->Copy()); + flags_ |= kEncodeHasISymbols; + } else { + isymbols_.reset(); + flags_ &= ~kEncodeHasISymbols; + } + } + + void SetOutputSymbols(const SymbolTable *syms) { + if (syms) { + osymbols_.reset(syms->Copy()); + flags_ |= kEncodeHasOSymbols; + } else { + osymbols_.reset(); + flags_ &= ~kEncodeHasOSymbols; + } + } + + private: + uint32 flags_; + std::vector> encode_tuples_; + EncodeHash encode_hash_; + std::unique_ptr isymbols_; // Pre-encoded input symbol table. + std::unique_ptr osymbols_; // Pre-encoded output symbol table. + + EncodeTable(const EncodeTable &) = delete; + EncodeTable &operator=(const EncodeTable &) = delete; +}; + +template +bool EncodeTable::Write(std::ostream &strm, + const string &source) const { + WriteType(strm, kEncodeMagicNumber); + WriteType(strm, flags_); + const int64 size = encode_tuples_.size(); + WriteType(strm, size); + for (const auto &tuple : encode_tuples_) { + WriteType(strm, tuple->ilabel); + WriteType(strm, tuple->olabel); + tuple->weight.Write(strm); + } + if (flags_ & kEncodeHasISymbols) isymbols_->Write(strm); + if (flags_ & kEncodeHasOSymbols) osymbols_->Write(strm); + strm.flush(); + if (!strm) { + LOG(ERROR) << "EncodeTable::Write: Write failed: " << source; + return false; + } + return true; +} + +template +EncodeTable *EncodeTable::Read(std::istream &strm, + const string &source) { + int32 magic_number = 0; + ReadType(strm, &magic_number); + if (magic_number != kEncodeMagicNumber) { + LOG(ERROR) << "EncodeTable::Read: Bad encode table header: " << source; + return nullptr; + } + uint32 flags; + ReadType(strm, &flags); + int64 size; + ReadType(strm, &size); + if (!strm) { + LOG(ERROR) << "EncodeTable::Read: Read failed: " << source; + return nullptr; + } + std::unique_ptr> table(new EncodeTable(flags)); + for (int64 i = 0; i < size; ++i) { + std::unique_ptr tuple(new Tuple()); + ReadType(strm, &tuple->ilabel); + ReadType(strm, &tuple->olabel); + tuple->weight.Read(strm); + if (!strm) { + LOG(ERROR) << "EncodeTable::Read: Read failed: " << source; + return nullptr; + } + table->encode_tuples_.push_back(std::move(tuple)); + table->encode_hash_[table->encode_tuples_.back().get()] = + table->encode_tuples_.size(); + } + if (flags & kEncodeHasISymbols) { + table->isymbols_.reset(SymbolTable::Read(strm, source)); + } + if (flags & kEncodeHasOSymbols) { + table->osymbols_.reset(SymbolTable::Read(strm, source)); + } + return table.release(); +} + +} // namespace internal + +// A mapper to encode/decode weighted transducers. Encoding of an FST is used +// for performing classical determinization or minimization on a weighted +// transducer viewing it as an unweighted acceptor over encoded labels. +// +// The mapper stores the encoding in a local hash table (EncodeTable). This +// table is shared (and reference-counted) between the encoder and decoder. +// A decoder has read-only access to the EncodeTable. +// +// The EncodeMapper allows on the fly encoding of the machine. As the +// EncodeTable is generated the same table may by used to decode the machine +// on the fly. For example in the following sequence of operations +// +// Encode -> Determinize -> Decode +// +// we will use the encoding table generated during the encode step in the +// decode, even though the encoding is not complete. +template +class EncodeMapper { + using Label = typename Arc::Label; + using Weight = typename Arc::Weight; + + public: + EncodeMapper(uint32 flags, EncodeType type) + : flags_(flags), + type_(type), + table_(std::make_shared>(flags)), + error_(false) {} + + EncodeMapper(const EncodeMapper &mapper) + : flags_(mapper.flags_), + type_(mapper.type_), + table_(mapper.table_), + error_(false) {} + + // Copy constructor but setting the type, typically to DECODE. + EncodeMapper(const EncodeMapper &mapper, EncodeType type) + : flags_(mapper.flags_), + type_(type), + table_(mapper.table_), + error_(mapper.error_) {} + + Arc operator()(const Arc &arc); + + MapFinalAction FinalAction() const { + return (type_ == ENCODE && (flags_ & kEncodeWeights)) + ? MAP_REQUIRE_SUPERFINAL + : MAP_NO_SUPERFINAL; + } + + constexpr MapSymbolsAction InputSymbolsAction() const { + return MAP_CLEAR_SYMBOLS; + } + + constexpr MapSymbolsAction OutputSymbolsAction() const { + return MAP_CLEAR_SYMBOLS; + } + + uint64 Properties(uint64 inprops) { + uint64 outprops = inprops; + if (error_) outprops |= kError; + uint64 mask = kFstProperties; + if (flags_ & kEncodeLabels) { + mask &= kILabelInvariantProperties & kOLabelInvariantProperties; + } + if (flags_ & kEncodeWeights) { + mask &= kILabelInvariantProperties & kWeightInvariantProperties & + (type_ == ENCODE ? kAddSuperFinalProperties + : kRmSuperFinalProperties); + } + return outprops & mask; + } + + uint32 Flags() const { return flags_; } + + EncodeType Type() const { return type_; } + + bool Write(std::ostream &strm, const string &source) const { + return table_->Write(strm, source); + } + + bool Write(const string &filename) const { + std::ofstream strm(filename, + std::ios_base::out | std::ios_base::binary); + if (!strm) { + LOG(ERROR) << "EncodeMap: Can't open file: " << filename; + return false; + } + return Write(strm, filename); + } + + static EncodeMapper *Read(std::istream &strm, const string &source, + EncodeType type = ENCODE) { + auto *table = internal::EncodeTable::Read(strm, source); + return table ? new EncodeMapper(table->Flags(), type, table) : nullptr; + } + + static EncodeMapper *Read(const string &filename, + EncodeType type = ENCODE) { + std::ifstream strm(filename, + std::ios_base::in | std::ios_base::binary); + if (!strm) { + LOG(ERROR) << "EncodeMap: Can't open file: " << filename; + return nullptr; + } + return Read(strm, filename, type); + } + + const SymbolTable *InputSymbols() const { return table_->InputSymbols(); } + + const SymbolTable *OutputSymbols() const { return table_->OutputSymbols(); } + + void SetInputSymbols(const SymbolTable *syms) { + table_->SetInputSymbols(syms); + } + + void SetOutputSymbols(const SymbolTable *syms) { + table_->SetOutputSymbols(syms); + } + + private: + uint32 flags_; + EncodeType type_; + std::shared_ptr> table_; + bool error_; + + explicit EncodeMapper(uint32 flags, EncodeType type, + internal::EncodeTable *table) + : flags_(flags), type_(type), table_(table), error_(false) {} + + EncodeMapper &operator=(const EncodeMapper &) = delete; +}; + +template +Arc EncodeMapper::operator()(const Arc &arc) { + if (type_ == ENCODE) { + if ((arc.nextstate == kNoStateId && !(flags_ & kEncodeWeights)) || + (arc.nextstate == kNoStateId && (flags_ & kEncodeWeights) && + arc.weight == Weight::Zero())) { + return arc; + } else { + const auto label = table_->Encode(arc); + return Arc(label, flags_ & kEncodeLabels ? label : arc.olabel, + flags_ & kEncodeWeights ? Weight::One() : arc.weight, + arc.nextstate); + } + } else { // type_ == DECODE + if (arc.nextstate == kNoStateId) { + return arc; + } else { + if (arc.ilabel == 0) return arc; + if (flags_ & kEncodeLabels && arc.ilabel != arc.olabel) { + FSTERROR() << "EncodeMapper: Label-encoded arc has different " + "input and output labels"; + error_ = true; + } + if (flags_ & kEncodeWeights && arc.weight != Weight::One()) { + FSTERROR() << "EncodeMapper: Weight-encoded arc has non-trivial weight"; + error_ = true; + } + const auto tuple = table_->Decode(arc.ilabel); + if (!tuple) { + FSTERROR() << "EncodeMapper: Decode failed"; + error_ = true; + return Arc(kNoLabel, kNoLabel, Weight::NoWeight(), arc.nextstate); + } else { + return Arc(tuple->ilabel, + flags_ & kEncodeLabels ? tuple->olabel : arc.olabel, + flags_ & kEncodeWeights ? tuple->weight : arc.weight, + arc.nextstate); + } + } + } +} + +// Complexity: O(E + V). +template +inline void Encode(MutableFst *fst, EncodeMapper *mapper) { + mapper->SetInputSymbols(fst->InputSymbols()); + mapper->SetOutputSymbols(fst->OutputSymbols()); + ArcMap(fst, mapper); +} + +template +inline void Decode(MutableFst *fst, const EncodeMapper &mapper) { + ArcMap(fst, EncodeMapper(mapper, DECODE)); + RmFinalEpsilon(fst); + fst->SetInputSymbols(mapper.InputSymbols()); + fst->SetOutputSymbols(mapper.OutputSymbols()); +} + +// On-the-fly encoding of an input FST. +// +// Complexity: +// +// Construction: O(1) +// Traversal: O(e + v) +// +// where e is the number of arcs visited and v is the number of states visited. +// Constant time and space to visit an input state or arc is assumed and +// exclusive of caching. +template +class EncodeFst : public ArcMapFst> { + public: + using Mapper = EncodeMapper; + using Impl = internal::ArcMapFstImpl; + + EncodeFst(const Fst &fst, Mapper *encoder) + : ArcMapFst(fst, encoder, ArcMapFstOptions()) { + encoder->SetInputSymbols(fst.InputSymbols()); + encoder->SetOutputSymbols(fst.OutputSymbols()); + } + + EncodeFst(const Fst &fst, const Mapper &encoder) + : ArcMapFst(fst, encoder, ArcMapFstOptions()) {} + + // See Fst<>::Copy() for doc. + EncodeFst(const EncodeFst &fst, bool copy = false) + : ArcMapFst(fst, copy) {} + + // Makes a copy of this EncodeFst. See Fst<>::Copy() for further doc. + EncodeFst *Copy(bool safe = false) const override { + if (safe) { + FSTERROR() << "EncodeFst::Copy(true): Not allowed"; + GetImpl()->SetProperties(kError, kError); + } + return new EncodeFst(*this); + } + + private: + using ImplToFst::GetImpl; + using ImplToFst::GetMutableImpl; +}; + +// On-the-fly decoding of an input FST. +// +// Complexity: +// +// Construction: O(1). +// Traversal: O(e + v) +// +// Constant time and space to visit an input state or arc is assumed and +// exclusive of caching. +template +class DecodeFst : public ArcMapFst> { + public: + using Mapper = EncodeMapper; + using Impl = internal::ArcMapFstImpl; + using ImplToFst::GetImpl; + + DecodeFst(const Fst &fst, const Mapper &encoder) + : ArcMapFst(fst, Mapper(encoder, DECODE), + ArcMapFstOptions()) { + GetMutableImpl()->SetInputSymbols(encoder.InputSymbols()); + GetMutableImpl()->SetOutputSymbols(encoder.OutputSymbols()); + } + + // See Fst<>::Copy() for doc. + DecodeFst(const DecodeFst &fst, bool safe = false) + : ArcMapFst(fst, safe) {} + + // Makes a copy of this DecodeFst. See Fst<>::Copy() for further doc. + DecodeFst *Copy(bool safe = false) const override { + return new DecodeFst(*this, safe); + } + + private: + using ImplToFst::GetMutableImpl; +}; + +// Specialization for EncodeFst. +template +class StateIterator> + : public StateIterator>> { + public: + explicit StateIterator(const EncodeFst &fst) + : StateIterator>>(fst) {} +}; + +// Specialization for EncodeFst. +template +class ArcIterator> + : public ArcIterator>> { + public: + ArcIterator(const EncodeFst &fst, typename Arc::StateId s) + : ArcIterator>>(fst, s) {} +}; + +// Specialization for DecodeFst. +template +class StateIterator> + : public StateIterator>> { + public: + explicit StateIterator(const DecodeFst &fst) + : StateIterator>>(fst) {} +}; + +// Specialization for DecodeFst. +template +class ArcIterator> + : public ArcIterator>> { + public: + ArcIterator(const DecodeFst &fst, typename Arc::StateId s) + : ArcIterator>>(fst, s) {} +}; + +// Useful aliases when using StdArc. + +using StdEncodeFst = EncodeFst; + +using StdDecodeFst = DecodeFst; + +} // namespace fst + +#endif // FST_ENCODE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/epsnormalize.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/epsnormalize.h new file mode 100644 index 0000000000..3496eddaa9 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/epsnormalize.h @@ -0,0 +1,58 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Function that implements epsilon-normalization. + +#ifndef FST_EPSNORMALIZE_H_ +#define FST_EPSNORMALIZE_H_ + + +#include +#include +#include +#include + + +namespace fst { + +enum EpsNormalizeType { EPS_NORM_INPUT, EPS_NORM_OUTPUT }; + +// Returns an equivalent FST that is epsilon-normalized. An acceptor is +// epsilon-normalized if it is epsilon-removed. A transducer is input +// epsilon-normalized if additionally if on each path any epsilon input +// label follows all non-epsilon input labels. Output epsilon-normalized +// is defined similarly. +// +// For more information, see: +// +// Mohri, M. 2002. Generic epsilon-removal and input epsilon-normalization +// algorithms for weighted transducers. International Journal of Computer +// Science, 13(1): 129-143, 2002. +template +void EpsNormalize(const Fst &ifst, MutableFst *ofst, + EpsNormalizeType type = EPS_NORM_INPUT) { + EpsNormalize(ifst, ofst, type); +} + +// Same as above, expect allows specifying explicitely the gallic weight type. +template +void EpsNormalize(const Fst &ifst, MutableFst *ofst, + EpsNormalizeType type) { + VectorFst> gfst; + if (type == EPS_NORM_INPUT) { + ArcMap(ifst, &gfst, ToGallicMapper()); + } else { // type == EPS_NORM_OUTPUT + ArcMap(InvertFst(ifst), &gfst, ToGallicMapper()); + } + RmEpsilon(&gfst); + FactorWeightFst, + GallicFactor> + fwfst(gfst); + ArcMap(fwfst, ofst, FromGallicMapper()); + ofst->SetOutputSymbols(ifst.OutputSymbols()); + if (type == EPS_NORM_OUTPUT) Invert(ofst); +} + +} // namespace fst + +#endif // FST_EPSNORMALIZE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/equal.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/equal.h new file mode 100644 index 0000000000..6a035c93a1 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/equal.h @@ -0,0 +1,139 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Function to test equality of two FSTs. + +#ifndef FST_EQUAL_H_ +#define FST_EQUAL_H_ + +#include + +#include +#include + + +namespace fst { + +constexpr uint32 kEqualFsts = 0x0001; +constexpr uint32 kEqualFstTypes = 0x0002; +constexpr uint32 kEqualCompatProperties = 0x0004; +constexpr uint32 kEqualCompatSymbols = 0x0008; +constexpr uint32 kEqualAll = + kEqualFsts | kEqualFstTypes | kEqualCompatProperties | kEqualCompatSymbols; + +// Tests if two Fsts have the same states and arcs in the same order (when +// etype & kEqualFst). +// Also optional checks equality of Fst types (etype & kEqualFstTypes) and +// compatibility of stored properties (etype & kEqualCompatProperties) and +// of symbol tables (etype & kEqualCompatSymbols). +template +bool Equal(const Fst &fst1, const Fst &fst2, float delta = kDelta, + uint32 etype = kEqualFsts) { + if ((etype & kEqualFstTypes) && (fst1.Type() != fst2.Type())) { + VLOG(1) << "Equal: Mismatched FST types (" << fst1.Type() << " != " + << fst2.Type() << ")"; + return false; + } + if ((etype & kEqualCompatProperties) && + !CompatProperties(fst1.Properties(kCopyProperties, false), + fst2.Properties(kCopyProperties, false))) { + VLOG(1) << "Equal: Properties not compatible"; + return false; + } + if (etype & kEqualCompatSymbols) { + if (!CompatSymbols(fst1.InputSymbols(), fst2.InputSymbols(), false)) { + VLOG(1) << "Equal: Input symbols not compatible"; + return false; + } + if (!CompatSymbols(fst1.OutputSymbols(), fst2.OutputSymbols(), false)) { + VLOG(1) << "Equal: Output symbols not compatible"; + return false; + } + } + if (!(etype & kEqualFsts)) return true; + if (fst1.Start() != fst2.Start()) { + VLOG(1) << "Equal: Mismatched start states (" << fst1.Start() << " != " + << fst2.Start() << ")"; + return false; + } + StateIterator> siter1(fst1); + StateIterator> siter2(fst2); + while (!siter1.Done() || !siter2.Done()) { + if (siter1.Done() || siter2.Done()) { + VLOG(1) << "Equal: Mismatched number of states"; + return false; + } + const auto s1 = siter1.Value(); + const auto s2 = siter2.Value(); + if (s1 != s2) { + VLOG(1) << "Equal: Mismatched states (" << s1 << "!= " + << s2 << ")"; + return false; + } + const auto &final1 = fst1.Final(s1); + const auto &final2 = fst2.Final(s2); + if (!ApproxEqual(final1, final2, delta)) { + VLOG(1) << "Equal: Mismatched final weights at state " << s1 + << " (" << final1 << " != " << final2 << ")"; + return false; + } + ArcIterator> aiter1(fst1, s1); + ArcIterator> aiter2(fst2, s2); + for (auto a = 0; !aiter1.Done() || !aiter2.Done(); ++a) { + if (aiter1.Done() || aiter2.Done()) { + VLOG(1) << "Equal: Mismatched number of arcs at state " << s1; + return false; + } + const auto &arc1 = aiter1.Value(); + const auto &arc2 = aiter2.Value(); + if (arc1.ilabel != arc2.ilabel) { + VLOG(1) << "Equal: Mismatched arc input labels at state " << s1 + << ", arc " << a << " (" << arc1.ilabel << " != " + << arc2.ilabel << ")"; + return false; + } else if (arc1.olabel != arc2.olabel) { + VLOG(1) << "Equal: Mismatched arc output labels at state " << s1 + << ", arc " << a << " (" << arc1.olabel << " != " + << arc2.olabel << ")"; + return false; + } else if (!ApproxEqual(arc1.weight, arc2.weight, delta)) { + VLOG(1) << "Equal: Mismatched arc weights at state " << s1 + << ", arc " << a << " (" << arc1.weight << " != " + << arc2.weight << ")"; + return false; + } else if (arc1.nextstate != arc2.nextstate) { + VLOG(1) << "Equal: Mismatched next state at state " << s1 + << ", arc " << a << " (" << arc1.nextstate << " != " + << arc2.nextstate << ")"; + return false; + } + aiter1.Next(); + aiter2.Next(); + } + // Sanity checks: should never fail. + if (fst1.NumArcs(s1) != fst2.NumArcs(s2)) { + FSTERROR() << "Equal: Inconsistent arc counts at state " << s1 + << " (" << fst1.NumArcs(s1) << " != " + << fst2.NumArcs(s2) << ")"; + return false; + } + if (fst1.NumInputEpsilons(s1) != fst2.NumInputEpsilons(s2)) { + FSTERROR() << "Equal: Inconsistent input epsilon counts at state " << s1 + << " (" << fst1.NumInputEpsilons(s1) << " != " + << fst2.NumInputEpsilons(s2) << ")"; + return false; + } + if (fst1.NumOutputEpsilons(s1) != fst2.NumOutputEpsilons(s2)) { + FSTERROR() << "Equal: Inconsistent output epsilon counts at state " << s1 + << " (" << fst1.NumOutputEpsilons(s1) << " != " + << fst2.NumOutputEpsilons(s2) << ")"; + } + siter1.Next(); + siter2.Next(); + } + return true; +} + +} // namespace fst + +#endif // FST_EQUAL_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/equivalent.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/equivalent.h new file mode 100644 index 0000000000..cf3fdb6109 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/equivalent.h @@ -0,0 +1,230 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Functions and classes to determine the equivalence of two FSTs. + +#ifndef FST_EQUIVALENT_H_ +#define FST_EQUIVALENT_H_ + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + + +namespace fst { +namespace internal { + +// Traits-like struct holding utility functions/typedefs/constants for +// the equivalence algorithm. +// +// Encoding device: in order to make the statesets of the two acceptors +// disjoint, we map Arc::StateId on the type MappedId. The states of +// the first acceptor are mapped on odd numbers (s -> 2s + 1), and +// those of the second one on even numbers (s -> 2s + 2). The number 0 +// is reserved for an implicit (non-final) dead state (required for +// the correct treatment of non-coaccessible states; kNoStateId is mapped to +// kDeadState for both acceptors). The union-find algorithm operates on the +// mapped IDs. +template +struct EquivalenceUtil { + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using MappedId = StateId; // ID for an equivalence class. + + // MappedId for an implicit dead state. + static constexpr MappedId kDeadState = 0; + + // MappedId for lookup failure. + static constexpr MappedId kInvalidId = -1; + + // Maps state ID to the representative of the corresponding + // equivalence class. The parameter 'which_fst' takes the values 1 + // and 2, identifying the input FST. + static MappedId MapState(StateId s, int32 which_fst) { + return (kNoStateId == s) ? kDeadState + : (static_cast(s) << 1) + which_fst; + } + + // Maps set ID to State ID. + static StateId UnMapState(MappedId id) { + return static_cast((--id) >> 1); + } + + // Convenience function: checks if state with MappedId s is final in + // acceptor fa. + static bool IsFinal(const Fst &fa, MappedId s) { + return (kDeadState == s) ? false + : (fa.Final(UnMapState(s)) != Weight::Zero()); + } + // Convenience function: returns the representative of ID in sets, + // creating a new set if needed. + static MappedId FindSet(UnionFind *sets, MappedId id) { + const auto repr = sets->FindSet(id); + if (repr != kInvalidId) { + return repr; + } else { + sets->MakeSet(id); + return id; + } + } +}; + +template +constexpr + typename EquivalenceUtil::MappedId EquivalenceUtil::kDeadState; + +template +constexpr + typename EquivalenceUtil::MappedId EquivalenceUtil::kInvalidId; + +} // namespace internal + +// Equivalence checking algorithm: determines if the two FSTs fst1 and fst2 +// are equivalent. The input FSTs must be deterministic input-side epsilon-free +// acceptors, unweighted or with weights over a left semiring. Two acceptors are +// considered equivalent if they accept exactly the same set of strings (with +// the same weights). +// +// The algorithm (cf. Aho, Hopcroft and Ullman, "The Design and Analysis of +// Computer Programs") successively constructs sets of states that can be +// reached by the same prefixes, starting with a set containing the start states +// of both acceptors. A disjoint tree forest (the union-find algorithm) is used +// to represent the sets of states. The algorithm returns false if one of the +// constructed sets contains both final and non-final states. Returns an +// optional error value (useful when FLAGS_error_fatal = false). +// +// Complexity: +// +// Quasi-linear, i.e., O(n G(n)), where +// +// n = |S1| + |S2| is the number of states in both acceptors +// +// G(n) is a very slowly growing function that can be approximated +// by 4 by all practical purposes. +template +bool Equivalent(const Fst &fst1, const Fst &fst2, + float delta = kDelta, bool *error = nullptr) { + using Weight = typename Arc::Weight; + if (error) *error = false; + // Check that the symbol table are compatible. + if (!CompatSymbols(fst1.InputSymbols(), fst2.InputSymbols()) || + !CompatSymbols(fst1.OutputSymbols(), fst2.OutputSymbols())) { + FSTERROR() << "Equivalent: Input/output symbol tables of 1st argument " + << "do not match input/output symbol tables of 2nd argument"; + if (error) *error = true; + return false; + } + // Check properties first. + static constexpr auto props = kNoEpsilons | kIDeterministic | kAcceptor; + if (fst1.Properties(props, true) != props) { + FSTERROR() << "Equivalent: 1st argument not an" + << " epsilon-free deterministic acceptor"; + if (error) *error = true; + return false; + } + if (fst2.Properties(props, true) != props) { + FSTERROR() << "Equivalent: 2nd argument not an" + << " epsilon-free deterministic acceptor"; + if (error) *error = true; + return false; + } + if ((fst1.Properties(kUnweighted, true) != kUnweighted) || + (fst2.Properties(kUnweighted, true) != kUnweighted)) { + VectorFst efst1(fst1); + VectorFst efst2(fst2); + Push(&efst1, REWEIGHT_TO_INITIAL, delta); + Push(&efst2, REWEIGHT_TO_INITIAL, delta); + ArcMap(&efst1, QuantizeMapper(delta)); + ArcMap(&efst2, QuantizeMapper(delta)); + EncodeMapper mapper(kEncodeWeights | kEncodeLabels, ENCODE); + ArcMap(&efst1, &mapper); + ArcMap(&efst2, &mapper); + return Equivalent(efst1, efst2); + } + using Util = internal::EquivalenceUtil; + using MappedId = typename Util::MappedId; + enum { FST1 = 1, FST2 = 2 }; // Required by Util::MapState(...) + auto s1 = Util::MapState(fst1.Start(), FST1); + auto s2 = Util::MapState(fst2.Start(), FST2); + // The union-find structure. + UnionFind eq_classes(1000, Util::kInvalidId); + // Initializes the union-find structure. + eq_classes.MakeSet(s1); + eq_classes.MakeSet(s2); + // Data structure for the (partial) acceptor transition function of fst1 and + // fst2: input labels mapped to pairs of MappedIds representing destination + // states of the corresponding arcs in fst1 and fst2, respectively. + using Label2StatePairMap = + std::unordered_map>; + Label2StatePairMap arc_pairs; + // Pairs of MappedId's to be processed, organized in a queue. + std::deque> q; + bool ret = true; + // Returns early if the start states differ w.r.t. finality. + if (Util::IsFinal(fst1, s1) != Util::IsFinal(fst2, s2)) ret = false; + // Main loop: explores the two acceptors in a breadth-first manner, updating + // the equivalence relation on the statesets. Loop invariant: each block of + // the states contains either final states only or non-final states only. + for (q.push_back(std::make_pair(s1, s2)); ret && !q.empty(); q.pop_front()) { + s1 = q.front().first; + s2 = q.front().second; + // Representatives of the equivalence classes of s1/s2. + const auto rep1 = Util::FindSet(&eq_classes, s1); + const auto rep2 = Util::FindSet(&eq_classes, s2); + if (rep1 != rep2) { + eq_classes.Union(rep1, rep2); + arc_pairs.clear(); + // Copies outgoing arcs starting at s1 into the hash-table. + if (Util::kDeadState != s1) { + ArcIterator> arc_iter(fst1, Util::UnMapState(s1)); + for (; !arc_iter.Done(); arc_iter.Next()) { + const auto &arc = arc_iter.Value(); + // Zero-weight arcs are treated as if they did not exist. + if (arc.weight != Weight::Zero()) { + arc_pairs[arc.ilabel].first = Util::MapState(arc.nextstate, FST1); + } + } + } + // Copies outgoing arcs starting at s2 into the hashtable. + if (Util::kDeadState != s2) { + ArcIterator> arc_iter(fst2, Util::UnMapState(s2)); + for (; !arc_iter.Done(); arc_iter.Next()) { + const auto &arc = arc_iter.Value(); + // Zero-weight arcs are treated as if they did not exist. + if (arc.weight != Weight::Zero()) { + arc_pairs[arc.ilabel].second = Util::MapState(arc.nextstate, FST2); + } + } + } + // Iterates through the hashtable and process pairs of target states. + for (const auto &arc_iter : arc_pairs) { + const auto &pair = arc_iter.second; + if (Util::IsFinal(fst1, pair.first) != + Util::IsFinal(fst2, pair.second)) { + // Detected inconsistency: return false. + ret = false; + break; + } + q.push_back(pair); + } + } + } + if (fst1.Properties(kError, false) || fst2.Properties(kError, false)) { + if (error) *error = true; + return false; + } + return ret; +} + +} // namespace fst + +#endif // FST_EQUIVALENT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/expanded-fst.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/expanded-fst.h new file mode 100644 index 0000000000..614ecef061 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/expanded-fst.h @@ -0,0 +1,183 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Generic FST augmented with state count-interface class definition. + +#ifndef FST_EXPANDED_FST_H_ +#define FST_EXPANDED_FST_H_ + +#include +#include +#include + +#include +#include + +#include + + +namespace fst { + +// A generic FST plus state count. +template +class ExpandedFst : public Fst { + public: + using Arc = A; + using StateId = typename Arc::StateId; + + virtual StateId NumStates() const = 0; // State count + + // Get a copy of this ExpandedFst. See Fst<>::Copy() for further doc. + ExpandedFst *Copy(bool safe = false) const override = 0; + + // Read an ExpandedFst from an input stream; return NULL on error. + static ExpandedFst *Read(std::istream &strm, + const FstReadOptions &opts) { + FstReadOptions ropts(opts); + FstHeader hdr; + if (ropts.header) { + hdr = *opts.header; + } else { + if (!hdr.Read(strm, opts.source)) return nullptr; + ropts.header = &hdr; + } + if (!(hdr.Properties() & kExpanded)) { + LOG(ERROR) << "ExpandedFst::Read: Not an ExpandedFst: " << ropts.source; + return nullptr; + } + const auto reader = + FstRegister::GetRegister()->GetReader(hdr.FstType()); + if (!reader) { + LOG(ERROR) << "ExpandedFst::Read: Unknown FST type \"" << hdr.FstType() + << "\" (arc type = \"" << A::Type() << "\"): " << ropts.source; + return nullptr; + } + auto *fst = reader(strm, ropts); + if (!fst) return nullptr; + return static_cast *>(fst); + } + + // Read an ExpandedFst from a file; return NULL on error. + // Empty filename reads from standard input. + static ExpandedFst *Read(const string &filename) { + if (!filename.empty()) { + std::ifstream strm(filename, + std::ios_base::in | std::ios_base::binary); + if (!strm) { + LOG(ERROR) << "ExpandedFst::Read: Can't open file: " << filename; + return nullptr; + } + return Read(strm, FstReadOptions(filename)); + } else { + return Read(std::cin, FstReadOptions("standard input")); + } + } +}; + +namespace internal { + +// ExpandedFst case - abstract methods. +template +inline typename Arc::Weight Final(const ExpandedFst &fst, + typename Arc::StateId s) { + return fst.Final(s); +} + +template +inline ssize_t NumArcs(const ExpandedFst &fst, typename Arc::StateId s) { + return fst.NumArcs(s); +} + +template +inline ssize_t NumInputEpsilons(const ExpandedFst &fst, + typename Arc::StateId s) { + return fst.NumInputEpsilons(s); +} + +template +inline ssize_t NumOutputEpsilons(const ExpandedFst &fst, + typename Arc::StateId s) { + return fst.NumOutputEpsilons(s); +} + +} // namespace internal + +// A useful alias when using StdArc. +using StdExpandedFst = ExpandedFst; + +// This is a helper class template useful for attaching an ExpandedFst +// interface to its implementation, handling reference counting. It +// delegates to ImplToFst the handling of the Fst interface methods. +template > +class ImplToExpandedFst : public ImplToFst { + public: + using Arc = typename FST::Arc; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using ImplToFst::operator=; + + StateId NumStates() const override { return GetImpl()->NumStates(); } + + protected: + using ImplToFst::GetImpl; + + explicit ImplToExpandedFst(std::shared_ptr impl) + : ImplToFst(impl) {} + + ImplToExpandedFst(const ImplToExpandedFst &fst) + : ImplToFst(fst) {} + + ImplToExpandedFst(const ImplToExpandedFst &fst, bool safe) + : ImplToFst(fst, safe) {} + + static Impl *Read(std::istream &strm, const FstReadOptions &opts) { + return Impl::Read(strm, opts); + } + + // Read FST implementation from a file; return NULL on error. + // Empty filename reads from standard input. + static Impl *Read(const string &filename) { + if (!filename.empty()) { + std::ifstream strm(filename, + std::ios_base::in | std::ios_base::binary); + if (!strm) { + LOG(ERROR) << "ExpandedFst::Read: Can't open file: " << filename; + return nullptr; + } + return Impl::Read(strm, FstReadOptions(filename)); + } else { + return Impl::Read(std::cin, FstReadOptions("standard input")); + } + } +}; + +// Function to return the number of states in an FST, counting them +// if necessary. +template +typename Arc::StateId CountStates(const Fst &fst) { + if (fst.Properties(kExpanded, false)) { + const auto *efst = static_cast *>(&fst); + return efst->NumStates(); + } else { + typename Arc::StateId nstates = 0; + for (StateIterator> siter(fst); !siter.Done(); siter.Next()) { + ++nstates; + } + return nstates; + } +} + +// Function to return the number of arcs in an FST. +template +typename Arc::StateId CountArcs(const Fst &fst) { + size_t narcs = 0; + for (StateIterator> siter(fst); !siter.Done(); siter.Next()) { + narcs += fst.NumArcs(siter.Value()); + } + return narcs; +} + +} // namespace fst + +#endif // FST_EXPANDED_FST_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/expectation-weight.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/expectation-weight.h new file mode 100644 index 0000000000..e639579491 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/expectation-weight.h @@ -0,0 +1,137 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Expectation semiring as described by Jason Eisner: +// See: doi=10.1.1.22.9398 +// Multiplex semiring operations and identities: +// One: +// Zero: +// Plus: + = < (a1 + a2) , (b1 + b2) > +// Times: * = < (a1 * a2) , [(a1 * b2) + (a2 * b1)] > +// Division: Undefined (currently) +// +// Usually used to store the pair so that +// ShortestDistance[Fst>>] +// == < PosteriorProbability, Expected_Value[V] > + +#ifndef FST_EXPECTATION_WEIGHT_H_ +#define FST_EXPECTATION_WEIGHT_H_ + +#include + +#include + +#include +#include + + +namespace fst { + +// X1 is usually a probability weight like LogWeight. +// X2 is usually a random variable or vector (see SignedLogWeight or +// SparsePowerWeight). +// +// If X1 is distinct from X2, it is required that there is an external product +// between X1 and X2 and if both semriring are commutative, or left or right +// semirings, then result must have those properties. +template +class ExpectationWeight : public PairWeight { + public: + using PairWeight::Value1; + using PairWeight::Value2; + + using PairWeight::Reverse; + using PairWeight::Quantize; + using PairWeight::Member; + + using ReverseWeight = + ExpectationWeight; + + ExpectationWeight() : PairWeight(Zero()) {} + + ExpectationWeight(const ExpectationWeight &weight) + : PairWeight(weight) {} + + explicit ExpectationWeight(const PairWeight &weight) + : PairWeight(weight) {} + + ExpectationWeight(const X1 &x1, const X2 &x2) : PairWeight(x1, x2) {} + + static const ExpectationWeight &Zero() { + static const ExpectationWeight zero(X1::Zero(), X2::Zero()); + return zero; + } + + static const ExpectationWeight &One() { + static const ExpectationWeight one(X1::One(), X2::Zero()); + return one; + } + + static const ExpectationWeight &NoWeight() { + static const ExpectationWeight no_weight(X1::NoWeight(), X2::NoWeight()); + return no_weight; + } + + static const string &Type() { + static const string *const type = + new string("expectation_" + X1::Type() + "_" + X2::Type()); + return *type; + } + + PairWeight Quantize(float delta = kDelta) const { + return ExpectationWeight(PairWeight::Quantize()); + } + + ReverseWeight Reverse() const { + return ReverseWeight(PairWeight::Reverse()); + } + + bool Member() const { return PairWeight::Member(); } + + static constexpr uint64 Properties() { + return X1::Properties() & X2::Properties() & + (kLeftSemiring | kRightSemiring | kCommutative | kIdempotent); + } +}; + +template +inline ExpectationWeight Plus(const ExpectationWeight &w1, + const ExpectationWeight &w2) { + return ExpectationWeight(Plus(w1.Value1(), w2.Value1()), + Plus(w1.Value2(), w2.Value2())); +} + +template +inline ExpectationWeight Times(const ExpectationWeight &w1, + const ExpectationWeight &w2) { + return ExpectationWeight( + Times(w1.Value1(), w2.Value1()), + Plus(Times(w1.Value1(), w2.Value2()), Times(w1.Value2(), w2.Value1()))); +} + +template +inline ExpectationWeight Divide(const ExpectationWeight &w1, + const ExpectationWeight &w2, + DivideType typ = DIVIDE_ANY) { + FSTERROR() << "ExpectationWeight::Divide: Not implemented"; + return ExpectationWeight::NoWeight(); +} + +// This function object generates weights by calling the underlying generators +// for the template weight types, like all other pair weight types. This is +// intended primarily for testing. +template +class WeightGenerate> + : public WeightGenerate> { + public: + using Weight = ExpectationWeight; + using Generate = WeightGenerate>; + + explicit WeightGenerate(bool allow_zero = true) : Generate(allow_zero) {} + + Weight operator()() const { return Weight(Generate::operator()()); } +}; + +} // namespace fst + +#endif // FST_EXPECTATION_WEIGHT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/compress/compress-script.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/compress/compress-script.h new file mode 100644 index 0000000000..d666598bf6 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/compress/compress-script.h @@ -0,0 +1,54 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Declarations of 'scriptable' versions of compression operations, that is, +// those that can be called with FstClass-type arguments. + +#ifndef FST_EXTENSIONS_COMPRESS_COMPRESS_SCRIPT_H_ +#define FST_EXTENSIONS_COMPRESS_COMPRESS_SCRIPT_H_ + +#include +#include + +#include + +#include +#include +#include +#include + +namespace fst { +namespace script { + +typedef std::tuple CompressArgs; + +template +void Compress(CompressArgs *args) { + const Fst &fst = *(std::get<0>(*args).GetFst()); + const string &filename = std::get<1>(*args); + const bool gzip = std::get<2>(*args); + + if (!fst::Compress(fst, filename, gzip)) FSTERROR() << "Compress: failed"; +} + +void Compress(const FstClass &fst, const string &filename, const bool gzip); + +typedef std::tuple + DecompressArgs; + +template +void Decompress(DecompressArgs *args) { + const string &filename = std::get<0>(*args); + MutableFst *fst = std::get<1>(*args)->GetMutableFst(); + const bool gzip = std::get<2>(*args); + + if (!fst::Decompress(filename, fst, gzip)) + FSTERROR() << "Decompress: failed"; +} + +void Decompress(const string &filename, MutableFstClass *fst, const bool gzip); + +} // namespace script +} // namespace fst + +#endif // FST_EXTENSIONS_COMPRESS_COMPRESS_SCRIPT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/compress/compress.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/compress/compress.h new file mode 100644 index 0000000000..59d25628b5 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/compress/compress.h @@ -0,0 +1,904 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Compresses and decompresses unweighted FSTs. + +#ifndef FST_EXTENSIONS_COMPRESS_COMPRESS_H_ +#define FST_EXTENSIONS_COMPRESS_COMPRESS_H_ + +#include + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +namespace fst { + +// Identifies stream data as a vanilla compressed FST. +static const int32 kCompressMagicNumber = 1858869554; +// Identifies stream data as (probably) a Gzip file accidentally read from +// a vanilla stream, without gzip support. +static const int32 kGzipMagicNumber = 0x8b1f; +// Selects the two most significant bytes. +constexpr uint32 kGzipMask = 0xffffffff >> 16; + +namespace internal { + +// Expands a Lempel Ziv code and returns the set of code words. expanded_code[i] +// is the i^th Lempel Ziv codeword. +template +bool ExpandLZCode(const std::vector> &code, + std::vector> *expanded_code) { + expanded_code->resize(code.size()); + for (int i = 0; i < code.size(); ++i) { + if (code[i].first > i) { + LOG(ERROR) << "ExpandLZCode: Not a valid code"; + return false; + } + if (code[i].first == 0) { + (*expanded_code)[i].resize(1, code[i].second); + } else { + (*expanded_code)[i].resize((*expanded_code)[code[i].first - 1].size() + + 1); + std::copy((*expanded_code)[code[i].first - 1].begin(), + (*expanded_code)[code[i].first - 1].end(), + (*expanded_code)[i].begin()); + (*expanded_code)[i][(*expanded_code)[code[i].first - 1].size()] = + code[i].second; + } + } + return true; +} + +} // namespace internal + +// Lempel Ziv on data structure Edge, with a less than operator +// EdgeLessThan and an equals operator EdgeEquals. +// Edge has a value defaultedge which it never takes and +// Edge is defined, it is initialized to defaultedge +template +class LempelZiv { + public: + LempelZiv() : dict_number_(0), default_edge_() { + root_.current_number = dict_number_++; + root_.current_edge = default_edge_; + decode_vector_.push_back(std::make_pair(0, default_edge_)); + } + // Encodes a vector input into output + void BatchEncode(const std::vector &input, + std::vector> *output); + + // Decodes codedvector to output. Returns false if + // the index exceeds the size. + bool BatchDecode(const std::vector> &input, + std::vector *output); + + // Decodes a single dictionary element. Returns false + // if the index exceeds the size. + bool SingleDecode(const Var &index, Edge *output) { + if (index >= decode_vector_.size()) { + LOG(ERROR) << "LempelZiv::SingleDecode: " + << "Index exceeded the dictionary size"; + return false; + } else { + *output = decode_vector_[index].second; + return true; + } + } + + ~LempelZiv() { + for (auto it = (root_.next_number).begin(); it != (root_.next_number).end(); + ++it) { + CleanUp(it->second); + } + } + // Adds a single dictionary element while decoding + // void AddDictElement(const std::pair &newdict) { + // EdgeEquals InstEdgeEquals; + // if (InstEdgeEquals(newdict.second, default_edge_) != 1) + // decode_vector_.push_back(newdict); + // } + + private: + // Node datastructure is used for encoding + + struct Node { + Var current_number; + Edge current_edge; + std::map next_number; + }; + + void CleanUp(Node *temp) { + for (auto it = (temp->next_number).begin(); it != (temp->next_number).end(); + ++it) { + CleanUp(it->second); + } + delete temp; + } + Node root_; + Var dict_number_; + // decode_vector_ is used for decoding + std::vector> decode_vector_; + Edge default_edge_; +}; + +template +void LempelZiv::BatchEncode( + const std::vector &input, std::vector> *output) { + for (typename std::vector::const_iterator it = input.begin(); + it != input.end(); ++it) { + Node *temp_node = &root_; + while (it != input.end()) { + auto next = (temp_node->next_number).find(*it); + if (next != (temp_node->next_number).end()) { + temp_node = next->second; + ++it; + } else { + break; + } + } + if (it == input.end() && temp_node->current_number != 0) { + output->push_back( + std::make_pair(temp_node->current_number, default_edge_)); + } else if (it != input.end()) { + output->push_back(std::make_pair(temp_node->current_number, *it)); + Node *new_node = new (Node); + new_node->current_number = dict_number_++; + new_node->current_edge = *it; + (temp_node->next_number)[*it] = new_node; + } + if (it == input.end()) break; + } +} + +template +bool LempelZiv::BatchDecode( + const std::vector> &input, std::vector *output) { + for (typename std::vector>::const_iterator it = + input.begin(); + it != input.end(); ++it) { + std::vector temp_output; + EdgeEquals InstEdgeEquals; + if (InstEdgeEquals(it->second, default_edge_) != 1) { + decode_vector_.push_back(*it); + temp_output.push_back(it->second); + } + Var temp_integer = it->first; + if (temp_integer >= decode_vector_.size()) { + LOG(ERROR) << "LempelZiv::BatchDecode: " + << "Index exceeded the dictionary size"; + return false; + } else { + while (temp_integer != 0) { + temp_output.push_back(decode_vector_[temp_integer].second); + temp_integer = decode_vector_[temp_integer].first; + } + std::reverse(temp_output.begin(), temp_output.end()); + output->insert(output->end(), temp_output.begin(), temp_output.end()); + } + } + return true; +} + +// The main Compressor class +template +class Compressor { + public: + typedef typename Arc::StateId StateId; + typedef typename Arc::Label Label; + typedef typename Arc::Weight Weight; + + Compressor() {} + + // Compresses fst into a boolean vector code. Returns true on sucesss. + bool Compress(const Fst &fst, std::ostream &strm); + + // Decompresses the boolean vector into Fst. Returns true on sucesss. + bool Decompress(std::istream &strm, const string &source, + MutableFst *fst); + + // Finds the BFS order of a fst + void BfsOrder(const ExpandedFst &fst, std::vector *order); + + // Preprocessing step to convert fst to a isomorphic fst + // Returns a preproccess fst and a dictionary + void Preprocess(const Fst &fst, MutableFst *preprocessedfst, + EncodeMapper *encoder); + + // Performs Lempel Ziv and outputs a stream of integers + // and sends it to a stream + void EncodeProcessedFst(const ExpandedFst &fst, std::ostream &strm); + + // Decodes fst from the stream + void DecodeProcessedFst(const std::vector &input, + MutableFst *fst, bool unweighted); + + // Converts buffer_code_ to uint8 and writes to a stream. + + // Writes the boolean file to the stream + void WriteToStream(std::ostream &strm); + + // Writes the weights to the stream + void WriteWeight(const std::vector &input, std::ostream &strm); + + void ReadWeight(std::istream &strm, std::vector *output); + + // Same as fst::Decode without the line RmFinalEpsilon(fst) + void DecodeForCompress(MutableFst *fst, const EncodeMapper &mapper); + + // Updates the buffer_code_ + template + void WriteToBuffer(CVar input) { + std::vector current_code; + Elias::DeltaEncode(input, ¤t_code); + if (!buffer_code_.empty()) { + buffer_code_.insert(buffer_code_.end(), current_code.begin(), + current_code.end()); + } else { + buffer_code_.assign(current_code.begin(), current_code.end()); + } + } + + private: + struct LZLabel { + LZLabel() : label(0) {} + Label label; + }; + + struct LabelLessThan { + bool operator()(const LZLabel &labelone, const LZLabel &labeltwo) const { + return labelone.label < labeltwo.label; + } + }; + + struct LabelEquals { + bool operator()(const LZLabel &labelone, const LZLabel &labeltwo) const { + return labelone.label == labeltwo.label; + } + }; + + struct Transition { + Transition() : nextstate(0), label(0), weight(Weight::Zero()) {} + + StateId nextstate; + Label label; + Weight weight; + }; + + struct TransitionLessThan { + bool operator()(const Transition &transition_one, + const Transition &transition_two) const { + if (transition_one.nextstate == transition_two.nextstate) + return transition_one.label < transition_two.label; + else + return transition_one.nextstate < transition_two.nextstate; + } + } transition_less_than; + + struct TransitionEquals { + bool operator()(const Transition &transition_one, + const Transition &transition_two) const { + return transition_one.nextstate == transition_two.nextstate && + transition_one.label == transition_two.label; + } + } transition_equals; + + struct OldDictCompare { + bool operator()(const std::pair &pair_one, + const std::pair &pair_two) const { + if ((pair_one.second).nextstate == (pair_two.second).nextstate) + return (pair_one.second).label < (pair_two.second).label; + else + return (pair_one.second).nextstate < (pair_two.second).nextstate; + } + } old_dict_compare; + + std::vector buffer_code_; + std::vector arc_weight_; + std::vector final_weight_; +}; + +template +inline void Compressor::DecodeForCompress( + MutableFst *fst, const EncodeMapper &mapper) { + ArcMap(fst, EncodeMapper(mapper, DECODE)); + fst->SetInputSymbols(mapper.InputSymbols()); + fst->SetOutputSymbols(mapper.OutputSymbols()); +} + +// Compressor::BfsOrder +template +void Compressor::BfsOrder(const ExpandedFst &fst, + std::vector *order) { + Arc arc; + StateId bfs_visit_number = 0; + std::queue states_queue; + order->assign(fst.NumStates(), kNoStateId); + states_queue.push(fst.Start()); + (*order)[fst.Start()] = bfs_visit_number++; + while (!states_queue.empty()) { + for (ArcIterator> aiter(fst, states_queue.front()); !aiter.Done(); + aiter.Next()) { + arc = aiter.Value(); + StateId nextstate = arc.nextstate; + if ((*order)[nextstate] == kNoStateId) { + (*order)[nextstate] = bfs_visit_number++; + states_queue.push(nextstate); + } + } + states_queue.pop(); + } + + // If the FST is unconnected, then the following + // code finds them + while (bfs_visit_number < fst.NumStates()) { + int unseen_state = 0; + for (unseen_state = 0; unseen_state < fst.NumStates(); ++unseen_state) { + if ((*order)[unseen_state] == kNoStateId) break; + } + states_queue.push(unseen_state); + (*order)[unseen_state] = bfs_visit_number++; + while (!states_queue.empty()) { + for (ArcIterator> aiter(fst, states_queue.front()); + !aiter.Done(); aiter.Next()) { + arc = aiter.Value(); + StateId nextstate = arc.nextstate; + if ((*order)[nextstate] == kNoStateId) { + (*order)[nextstate] = bfs_visit_number++; + states_queue.push(nextstate); + } + } + states_queue.pop(); + } + } +} + +template +void Compressor::Preprocess(const Fst &fst, + MutableFst *preprocessedfst, + EncodeMapper *encoder) { + *preprocessedfst = fst; + if (!preprocessedfst->NumStates()) { + return; + } + // Relabels the edges and develops a dictionary + Encode(preprocessedfst, encoder); + std::vector order; + // Finds the BFS sorting order of the fst + BfsOrder(*preprocessedfst, &order); + // Reorders the states according to the BFS order + StateSort(preprocessedfst, order); +} + +template +void Compressor::EncodeProcessedFst(const ExpandedFst &fst, + std::ostream &strm) { + std::vector output; + LempelZiv dict_new; + LempelZiv dict_old; + std::vector current_new_input; + std::vector current_old_input; + std::vector> current_new_output; + std::vector> current_old_output; + std::vector final_states; + + StateId number_of_states = fst.NumStates(); + + StateId seen_states = 0; + // Adding the number of states + WriteToBuffer(number_of_states); + + for (StateId state = 0; state < number_of_states; ++state) { + current_new_input.clear(); + current_old_input.clear(); + current_new_output.clear(); + current_old_output.clear(); + if (state > seen_states) ++seen_states; + + // Collecting the final states + if (fst.Final(state) != Weight::Zero()) { + final_states.push_back(state); + final_weight_.push_back(fst.Final(state)); + } + + // Reading the states + for (ArcIterator> aiter(fst, state); !aiter.Done(); aiter.Next()) { + Arc arc = aiter.Value(); + if (arc.nextstate > seen_states) { // RILEY: > or >= ? + ++seen_states; + LZLabel temp_label; + temp_label.label = arc.ilabel; + arc_weight_.push_back(arc.weight); + current_new_input.push_back(temp_label); + } else { + Transition temp_transition; + temp_transition.nextstate = arc.nextstate; + temp_transition.label = arc.ilabel; + temp_transition.weight = arc.weight; + current_old_input.push_back(temp_transition); + } + } + // Adding new states + dict_new.BatchEncode(current_new_input, ¤t_new_output); + WriteToBuffer(current_new_output.size()); + + for (auto it = current_new_output.begin(); it != current_new_output.end(); + ++it) { + WriteToBuffer(it->first); + WriteToBuffer. +// See the FarReader interface in far.h for the exact semantics. +class FarReaderImplBase { + public: + virtual const string &ArcType() const = 0; + virtual bool Done() const = 0; + virtual bool Error() const = 0; + virtual const string &GetKey() const = 0; + virtual const FstClass *GetFstClass() const = 0; + virtual bool Find(const string &key) = 0; + virtual void Next() = 0; + virtual void Reset() = 0; + virtual FarType Type() const = 0; + virtual ~FarReaderImplBase() {} +}; + +// Templated implementation. +template +class FarReaderClassImpl : public FarReaderImplBase { + public: + explicit FarReaderClassImpl(const string &filename) + : impl_(FarReader::Open(filename)) {} + + explicit FarReaderClassImpl(const std::vector &filenames) + : impl_(FarReader::Open(filenames)) {} + + const string &ArcType() const final { return Arc::Type(); } + + bool Done() const final { return impl_->Done(); } + + bool Error() const final { return impl_->Error(); } + + bool Find(const string &key) final { return impl_->Find(key); } + + const FstClass *GetFstClass() const final { + fstc_.reset(new FstClass(*impl_->GetFst())); + return fstc_.get(); + } + + const string &GetKey() const final { return impl_->GetKey(); } + + void Next() final { return impl_->Next(); } + + void Reset() final { impl_->Reset(); } + + FarType Type() const final { return impl_->Type(); } + + const FarReader *GetImpl() const { return impl_.get(); } + + FarReader *GetImpl() { return impl_.get(); } + + private: + std::unique_ptr> impl_; + mutable std::unique_ptr fstc_; +}; + + +class FarReaderClass; + +using OpenFarReaderClassArgs1 = + WithReturnValue; + +using OpenFarReaderClassArgs2 = + WithReturnValue &>; + +// Untemplated user-facing class holding a templated pimpl. +class FarReaderClass { + public: + const string &ArcType() const { return impl_->ArcType(); } + + bool Done() const { return impl_->Done(); } + + // Returns True if the impl is null (i.e., due to read failure). + // Attempting to call any other function will result in null dereference. + bool Error() const { return (impl_) ? impl_->Error() : true; } + + bool Find(const string &key) { return impl_->Find(key); } + + const FstClass *GetFstClass() const { return impl_->GetFstClass(); } + + const string &GetKey() const { return impl_->GetKey(); } + + void Next() { impl_->Next(); } + + void Reset() { impl_->Reset(); } + + FarType Type() const { return impl_->Type(); } + + template + const FarReader *GetFarReader() const { + if (Arc::Type() != ArcType()) return nullptr; + const FarReaderClassImpl *typed_impl = + static_cast *>(impl_.get()); + return typed_impl->GetImpl(); + } + + template + FarReader *GetFarReader() { + if (Arc::Type() != ArcType()) return nullptr; + FarReaderClassImpl *typed_impl = + static_cast *>(impl_.get()); + return typed_impl->GetImpl(); + } + + template + friend void OpenFarReaderClass(OpenFarReaderClassArgs1 *args); + + template + friend void OpenFarReaderClass(OpenFarReaderClassArgs2 *args); + + // Defined in the CC. + + static FarReaderClass *Open(const string &filename); + + static FarReaderClass *Open(const std::vector &filenames); + + private: + template + explicit FarReaderClass(FarReaderClassImpl *impl) : impl_(impl) {} + + std::unique_ptr impl_; +}; + +// These exist solely for registration purposes; users should call the +// static method FarReaderClass::Open instead. + +template +void OpenFarReaderClass(OpenFarReaderClassArgs1 *args) { + args->retval = new FarReaderClass(new FarReaderClassImpl(args->args)); +} + +template +void OpenFarReaderClass(OpenFarReaderClassArgs2 *args) { + args->retval = new FarReaderClass(new FarReaderClassImpl(args->args)); +} + +// FarWriter API. + +// Virtual interface implemented by each concrete FarWriterImpl. +class FarWriterImplBase { + public: + // Unlike the lower-level library, this returns a boolean to signal failure + // due to non-conformant arc types. + virtual bool Add(const string &key, const FstClass &fst) = 0; + virtual const string &ArcType() const = 0; + virtual bool Error() const = 0; + virtual FarType Type() const = 0; + virtual ~FarWriterImplBase() {} +}; + + +// Templated implementation. +template +class FarWriterClassImpl : public FarWriterImplBase { + public: + explicit FarWriterClassImpl(const string &filename, + FarType type = FAR_DEFAULT) + : impl_(FarWriter::Create(filename, type)) {} + + bool Add(const string &key, const FstClass &fst) final { + if (ArcType() != fst.ArcType()) { + FSTERROR() << "Cannot write FST with " << fst.ArcType() << " arcs to " + << "FAR with " << ArcType() << " arcs"; + return false; + } + impl_->Add(key, *(fst.GetFst())); + return true; + } + + const string &ArcType() const final { return Arc::Type(); } + + bool Error() const final { return impl_->Error(); } + + FarType Type() const final { return impl_->Type(); } + + const FarWriter *GetImpl() const { return impl_.get(); } + + FarWriter *GetImpl() { return impl_.get(); } + + private: + std::unique_ptr> impl_; +}; + + +class FarWriterClass; + +using CreateFarWriterClassInnerArgs = std::pair; + +using CreateFarWriterClassArgs = + WithReturnValue; + +// Untemplated user-facing class holding a templated pimpl. +class FarWriterClass { + public: + static FarWriterClass *Create(const string &filename, const string &arc_type, + FarType type = FAR_DEFAULT); + + bool Add(const string &key, const FstClass &fst) { + return impl_->Add(key, fst); + } + + // Returns True if the impl is null (i.e., due to construction failure). + // Attempting to call any other function will result in null dereference. + bool Error() const { return (impl_) ? impl_->Error() : true; } + + const string &ArcType() const { return impl_->ArcType(); } + + FarType Type() const { return impl_->Type(); } + + template + const FarWriter *GetFarWriter() const { + if (Arc::Type() != ArcType()) return nullptr; + const FarWriterClassImpl *typed_impl = + static_cast *>(impl_.get()); + return typed_impl->GetImpl(); + } + + template + FarWriter *GetFarWriter() { + if (Arc::Type() != ArcType()) return nullptr; + FarWriterClassImpl *typed_impl = + static_cast *>(impl_.get()); + return typed_impl->GetImpl(); + } + + template + friend void CreateFarWriterClass(CreateFarWriterClassArgs *args); + + private: + template + explicit FarWriterClass(FarWriterClassImpl *impl) : impl_(impl) {} + + std::unique_ptr impl_; +}; + +// This exists solely for registration purposes; users should call the +// static method FarWriterClass::Create instead. +template +void CreateFarWriterClass(CreateFarWriterClassArgs *args) { + args->retval = new FarWriterClass(new FarWriterClassImpl( + std::get<0>(args->args), std::get<1>(args->args))); +} + +} // namespace script +} // namespace fst + +#endif // FST_EXTENSIONS_FAR_FAR_CLASS_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/far.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/far.h new file mode 100644 index 0000000000..a2ad40bf96 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/far.h @@ -0,0 +1,476 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Finite-State Transducer (FST) archive classes. + +#ifndef FST_EXTENSIONS_FAR_FAR_H_ +#define FST_EXTENSIONS_FAR_FAR_H_ + +#include +#include + +#include +#include +#include +#include +#include +#include + +namespace fst { + +enum FarEntryType { FET_LINE, FET_FILE }; + +enum FarTokenType { FTT_SYMBOL, FTT_BYTE, FTT_UTF8 }; + +inline bool IsFst(const string &filename) { + std::ifstream strm(filename, std::ios_base::in | std::ios_base::binary); + if (!strm) return false; + return IsFstHeader(strm, filename); +} + +// FST archive header class +class FarHeader { + public: + const string &ArcType() const { return arctype_; } + + const string &FarType() const { return fartype_; } + + bool Read(const string &filename) { + FstHeader fsthdr; + if (filename.empty()) { + // Header reading unsupported on stdin. Assumes STList and StdArc. + fartype_ = "stlist"; + arctype_ = "standard"; + return true; + } else if (IsSTTable(filename)) { // Checks if STTable. + ReadSTTableHeader(filename, &fsthdr); + fartype_ = "sttable"; + arctype_ = fsthdr.ArcType().empty() ? "unknown" : fsthdr.ArcType(); + return true; + } else if (IsSTList(filename)) { // Checks if STList. + ReadSTListHeader(filename, &fsthdr); + fartype_ = "stlist"; + arctype_ = fsthdr.ArcType().empty() ? "unknown" : fsthdr.ArcType(); + return true; + } else if (IsFst(filename)) { // Checks if FST. + std::ifstream istrm(filename, + std::ios_base::in | std::ios_base::binary); + fsthdr.Read(istrm, filename); + fartype_ = "fst"; + arctype_ = fsthdr.ArcType().empty() ? "unknown" : fsthdr.ArcType(); + return true; + } + return false; + } + + private: + string fartype_; + string arctype_; +}; + +enum FarType { + FAR_DEFAULT = 0, + FAR_STTABLE = 1, + FAR_STLIST = 2, + FAR_FST = 3, +}; + +// This class creates an archive of FSTs. +template +class FarWriter { + public: + using Arc = A; + + // Creates a new (empty) FST archive; returns null on error. + static FarWriter *Create(const string &filename, FarType type = FAR_DEFAULT); + + // Adds an FST to the end of an archive. Keys must be non-empty and + // in lexicographic order. FSTs must have a suitable write method. + virtual void Add(const string &key, const Fst &fst) = 0; + + virtual FarType Type() const = 0; + + virtual bool Error() const = 0; + + virtual ~FarWriter() {} + + protected: + FarWriter() {} +}; + +// This class iterates through an existing archive of FSTs. +template +class FarReader { + public: + using Arc = A; + + // Opens an existing FST archive in a single file; returns null on error. + // Sets current position to the beginning of the achive. + static FarReader *Open(const string &filename); + + // Opens an existing FST archive in multiple files; returns null on error. + // Sets current position to the beginning of the achive. + static FarReader *Open(const std::vector &filenames); + + // Resets current position to beginning of archive. + virtual void Reset() = 0; + + // Sets current position to first entry >= key. Returns true if a match. + virtual bool Find(const string &key) = 0; + + // Current position at end of archive? + virtual bool Done() const = 0; + + // Move current position to next FST. + virtual void Next() = 0; + + // Returns key at the current position. This reference is invalidated if + // the current position in the archive is changed. + virtual const string &GetKey() const = 0; + + // Returns pointer to FST at the current position. This is invalidated if + // the current position in the archive is changed. + virtual const Fst *GetFst() const = 0; + + virtual FarType Type() const = 0; + + virtual bool Error() const = 0; + + virtual ~FarReader() {} + + protected: + FarReader() {} +}; + +template +class FstWriter { + public: + void operator()(std::ostream &strm, const Fst &fst) const { + fst.Write(strm, FstWriteOptions()); + } +}; + +template +class STTableFarWriter : public FarWriter { + public: + using Arc = A; + + static STTableFarWriter *Create(const string &filename) { + auto *writer = STTableWriter, FstWriter>::Create(filename); + return new STTableFarWriter(writer); + } + + void Add(const string &key, const Fst &fst) final { + writer_->Add(key, fst); + } + + FarType Type() const final { return FAR_STTABLE; } + + bool Error() const final { return writer_->Error(); } + + private: + explicit STTableFarWriter(STTableWriter, FstWriter> *writer) + : writer_(writer) {} + + std::unique_ptr, FstWriter>> writer_; +}; + +template +class STListFarWriter : public FarWriter { + public: + using Arc = A; + + static STListFarWriter *Create(const string &filename) { + auto *writer = STListWriter, FstWriter>::Create(filename); + return new STListFarWriter(writer); + } + + void Add(const string &key, const Fst &fst) final { + writer_->Add(key, fst); + } + + constexpr FarType Type() const final { return FAR_STLIST; } + + bool Error() const final { return writer_->Error(); } + + private: + explicit STListFarWriter(STListWriter, FstWriter> *writer) + : writer_(writer) {} + + std::unique_ptr, FstWriter>> writer_; +}; + +template +class FstFarWriter : public FarWriter { + public: + using Arc = A; + + explicit FstFarWriter(const string &filename) + : filename_(filename), error_(false), written_(false) {} + + static FstFarWriter *Create(const string &filename) { + return new FstFarWriter(filename); + } + + void Add(const string &key, const Fst &fst) final { + if (written_) { + LOG(WARNING) << "FstFarWriter::Add: only one FST supported," + << " subsequent entries discarded."; + } else { + error_ = !fst.Write(filename_); + written_ = true; + } + } + + constexpr FarType Type() const final { return FAR_FST; } + + bool Error() const final { return error_; } + + ~FstFarWriter() final {} + + private: + string filename_; + bool error_; + bool written_; +}; + +template +FarWriter *FarWriter::Create(const string &filename, FarType type) { + switch (type) { + case FAR_DEFAULT: + if (filename.empty()) return STListFarWriter::Create(filename); + case FAR_STTABLE: + return STTableFarWriter::Create(filename); + case FAR_STLIST: + return STListFarWriter::Create(filename); + case FAR_FST: + return FstFarWriter::Create(filename); + default: + LOG(ERROR) << "FarWriter::Create: Unknown FAR type"; + return nullptr; + } +} + +template +class FstReader { + public: + Fst *operator()(std::istream &strm) const { + return Fst::Read(strm, FstReadOptions()); + } +}; + +template +class STTableFarReader : public FarReader { + public: + using Arc = A; + + static STTableFarReader *Open(const string &filename) { + auto *reader = STTableReader, FstReader>::Open(filename); + if (!reader || reader->Error()) return nullptr; + return new STTableFarReader(reader); + } + + static STTableFarReader *Open(const std::vector &filenames) { + auto *reader = STTableReader, FstReader>::Open(filenames); + if (!reader || reader->Error()) return nullptr; + return new STTableFarReader(reader); + } + + void Reset() final { reader_->Reset(); } + + bool Find(const string &key) final { return reader_->Find(key); } + + bool Done() const final { return reader_->Done(); } + + void Next() final { return reader_->Next(); } + + const string &GetKey() const final { return reader_->GetKey(); } + + const Fst *GetFst() const final { return reader_->GetEntry(); } + + constexpr FarType Type() const final { return FAR_STTABLE; } + + bool Error() const final { return reader_->Error(); } + + private: + explicit STTableFarReader(STTableReader, FstReader> *reader) + : reader_(reader) {} + + std::unique_ptr, FstReader>> reader_; +}; + +template +class STListFarReader : public FarReader { + public: + using Arc = A; + + static STListFarReader *Open(const string &filename) { + auto *reader = STListReader, FstReader>::Open(filename); + if (!reader || reader->Error()) return nullptr; + return new STListFarReader(reader); + } + + static STListFarReader *Open(const std::vector &filenames) { + auto *reader = STListReader, FstReader>::Open(filenames); + if (!reader || reader->Error()) return nullptr; + return new STListFarReader(reader); + } + + void Reset() final { reader_->Reset(); } + + bool Find(const string &key) final { return reader_->Find(key); } + + bool Done() const final { return reader_->Done(); } + + void Next() final { return reader_->Next(); } + + const string &GetKey() const final { return reader_->GetKey(); } + + const Fst *GetFst() const final { return reader_->GetEntry(); } + + constexpr FarType Type() const final { return FAR_STLIST; } + + bool Error() const final { return reader_->Error(); } + + private: + explicit STListFarReader(STListReader, FstReader> *reader) + : reader_(reader) {} + + std::unique_ptr, FstReader>> reader_; +}; + +template +class FstFarReader : public FarReader { + public: + using Arc = A; + + static FstFarReader *Open(const string &filename) { + std::vector filenames; + filenames.push_back(filename); + return new FstFarReader(filenames); + } + + static FstFarReader *Open(const std::vector &filenames) { + return new FstFarReader(filenames); + } + + explicit FstFarReader(const std::vector &filenames) + : keys_(filenames), has_stdin_(false), pos_(0), error_(false) { + std::sort(keys_.begin(), keys_.end()); + streams_.resize(keys_.size(), 0); + for (size_t i = 0; i < keys_.size(); ++i) { + if (keys_[i].empty()) { + if (!has_stdin_) { + streams_[i] = &std::cin; + // sources_[i] = "stdin"; + has_stdin_ = true; + } else { + FSTERROR() << "FstFarReader::FstFarReader: standard input should " + "only appear once in the input file list"; + error_ = true; + return; + } + } else { + streams_[i] = new std::ifstream( + keys_[i], std::ios_base::in | std::ios_base::binary); + } + } + if (pos_ >= keys_.size()) return; + ReadFst(); + } + + void Reset() final { + if (has_stdin_) { + FSTERROR() + << "FstFarReader::Reset: Operation not supported on standard input"; + error_ = true; + return; + } + pos_ = 0; + ReadFst(); + } + + bool Find(const string &key) final { + if (has_stdin_) { + FSTERROR() + << "FstFarReader::Find: Operation not supported on standard input"; + error_ = true; + return false; + } + pos_ = 0; // TODO + ReadFst(); + return true; + } + + bool Done() const final { return error_ || pos_ >= keys_.size(); } + + void Next() final { + ++pos_; + ReadFst(); + } + + const string &GetKey() const final { return keys_[pos_]; } + + const Fst *GetFst() const final { return fst_.get(); } + + constexpr FarType Type() const final { return FAR_FST; } + + bool Error() const final { return error_; } + + ~FstFarReader() final { + for (size_t i = 0; i < keys_.size(); ++i) { + if (streams_[i] != &std::cin) { + delete streams_[i]; + } + } + } + + private: + void ReadFst() { + fst_.reset(); + if (pos_ >= keys_.size()) return; + streams_[pos_]->seekg(0); + fst_.reset(Fst::Read(*streams_[pos_], FstReadOptions())); + if (!fst_) { + FSTERROR() << "FstFarReader: Error reading Fst from: " << keys_[pos_]; + error_ = true; + } + } + + std::vector keys_; + std::vector streams_; + bool has_stdin_; + size_t pos_; + mutable std::unique_ptr> fst_; + mutable bool error_; +}; + +template +FarReader *FarReader::Open(const string &filename) { + if (filename.empty()) + return STListFarReader::Open(filename); + else if (IsSTTable(filename)) + return STTableFarReader::Open(filename); + else if (IsSTList(filename)) + return STListFarReader::Open(filename); + else if (IsFst(filename)) + return FstFarReader::Open(filename); + return nullptr; +} + +template +FarReader *FarReader::Open(const std::vector &filenames) { + if (!filenames.empty() && filenames[0].empty()) + return STListFarReader::Open(filenames); + else if (!filenames.empty() && IsSTTable(filenames[0])) + return STTableFarReader::Open(filenames); + else if (!filenames.empty() && IsSTList(filenames[0])) + return STListFarReader::Open(filenames); + else if (!filenames.empty() && IsFst(filenames[0])) + return FstFarReader::Open(filenames); + return nullptr; +} + +} // namespace fst + +#endif // FST_EXTENSIONS_FAR_FAR_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/farlib.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/farlib.h new file mode 100644 index 0000000000..c9bb171059 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/farlib.h @@ -0,0 +1,19 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// A finite-state archive (FAR) is used to store an indexable collection of +// FSTs in a single file. Utilities are provided to create FARs from FSTs, +// to iterate over FARs, and to extract specific FSTs from FARs. + +#ifndef FST_EXTENSIONS_FAR_FARLIB_H_ +#define FST_EXTENSIONS_FAR_FARLIB_H_ + +#include +#include +#include +#include +#include +#include +#include + +#endif // FST_EXTENSIONS_FAR_FARLIB_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/farscript.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/farscript.h new file mode 100644 index 0000000000..4bd11a9456 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/farscript.h @@ -0,0 +1,269 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Convenience file for including all of the FAR operations, or registering +// them for new arc types. + +#ifndef FST_EXTENSIONS_FAR_FARSCRIPT_H_ +#define FST_EXTENSIONS_FAR_FARSCRIPT_H_ + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace fst { +namespace script { + +// Note: it is safe to pass these strings as references because this struct is +// only used to pass them deeper in the call graph. Be sure you understand why +// this is so before using this struct for anything else! +struct FarCompileStringsArgs { + const std::vector &in_fnames; + const string &out_fname; + const string &fst_type; + const FarType &far_type; + const int32 generate_keys; + const FarEntryType fet; + const FarTokenType tt; + const string &symbols_fname; + const string &unknown_symbol; + const bool keep_symbols; + const bool initial_symbols; + const bool allow_negative_labels; + const string &key_prefix; + const string &key_suffix; + + FarCompileStringsArgs(const std::vector &in_fnames, + const string &out_fname, const string &fst_type, + const FarType &far_type, int32 generate_keys, + FarEntryType fet, FarTokenType tt, + const string &symbols_fname, + const string &unknown_symbol, bool keep_symbols, + bool initial_symbols, bool allow_negative_labels, + const string &key_prefix, const string &key_suffix) + : in_fnames(in_fnames), + out_fname(out_fname), + fst_type(fst_type), + far_type(far_type), + generate_keys(generate_keys), + fet(fet), + tt(tt), + symbols_fname(symbols_fname), + unknown_symbol(unknown_symbol), + keep_symbols(keep_symbols), + initial_symbols(initial_symbols), + allow_negative_labels(allow_negative_labels), + key_prefix(key_prefix), + key_suffix(key_suffix) {} +}; + +template +void FarCompileStrings(FarCompileStringsArgs *args) { + FarCompileStrings( + args->in_fnames, args->out_fname, args->fst_type, args->far_type, + args->generate_keys, args->fet, args->tt, args->symbols_fname, + args->unknown_symbol, args->keep_symbols, args->initial_symbols, + args->allow_negative_labels, args->key_prefix, args->key_suffix); +} + +void FarCompileStrings(const std::vector &in_fnames, + const string &out_fname, const string &arc_type, + const string &fst_type, const FarType &far_type, + int32 generate_keys, FarEntryType fet, FarTokenType tt, + const string &symbols_fname, + const string &unknown_symbol, bool keep_symbols, + bool initial_symbols, bool allow_negative_labels, + const string &key_prefix, const string &key_suffix); + +// Note: it is safe to pass these strings as references because this struct is +// only used to pass them deeper in the call graph. Be sure you understand why +// this is so before using this struct for anything else! +struct FarCreateArgs { + const std::vector &in_fnames; + const string &out_fname; + const int32 generate_keys; + const FarType &far_type; + const string &key_prefix; + const string &key_suffix; + + FarCreateArgs(const std::vector &in_fnames, const string &out_fname, + const int32 generate_keys, const FarType &far_type, + const string &key_prefix, const string &key_suffix) + : in_fnames(in_fnames), + out_fname(out_fname), + generate_keys(generate_keys), + far_type(far_type), + key_prefix(key_prefix), + key_suffix(key_suffix) {} +}; + +template +void FarCreate(FarCreateArgs *args) { + FarCreate(args->in_fnames, args->out_fname, args->generate_keys, + args->far_type, args->key_prefix, args->key_suffix); +} + +void FarCreate(const std::vector &in_fnames, const string &out_fname, + const string &arc_type, const int32 generate_keys, + const FarType &far_type, const string &key_prefix, + const string &key_suffix); + +using FarEqualInnerArgs = std::tuple; + +using FarEqualArgs = WithReturnValue; + +template +void FarEqual(FarEqualArgs *args) { + args->retval = fst::FarEqual( + std::get<0>(args->args), std::get<1>(args->args), std::get<2>(args->args), + std::get<3>(args->args), std::get<4>(args->args)); +} + +bool FarEqual(const string &filename1, const string &filename2, + const string &arc_type, float delta = kDelta, + const string &begin_key = string(), + const string &end_key = string()); + +using FarExtractArgs = + std::tuple &, int32, const string &, + const string &, const string &, const string &, const string &>; + +template +void FarExtract(FarExtractArgs *args) { + fst::FarExtract(std::get<0>(*args), std::get<1>(*args), + std::get<2>(*args), std::get<3>(*args), + std::get<4>(*args), std::get<5>(*args), + std::get<6>(*args)); +} + +void FarExtract(const std::vector &ifilenames, const string &arc_type, + int32 generate_filenames, const string &keys, + const string &key_separator, const string &range_delimiter, + const string &filename_prefix, const string &filename_suffix); + +using FarInfoArgs = std::tuple &, const string &, + const string &, const bool>; + +template +void FarInfo(FarInfoArgs *args) { + fst::FarInfo(std::get<0>(*args), std::get<1>(*args), + std::get<2>(*args), std::get<3>(*args)); +} + +void FarInfo(const std::vector &filenames, const string &arc_type, + const string &begin_key, const string &end_key, + const bool list_fsts); + +using GetFarInfoArgs = std::tuple &, const string &, + const string &, const bool, FarInfoData *>; + +template +void GetFarInfo(GetFarInfoArgs *args) { + fst::GetFarInfo(std::get<0>(*args), std::get<1>(*args), + std::get<2>(*args), std::get<3>(*args), + std::get<4>(*args)); +} + +void GetFarInfo(const std::vector &filenames, const string &arc_type, + const string &begin_key, const string &end_key, + const bool list_fsts, FarInfoData *); + +using FarIsomorphicInnerArgs = std::tuple; + +using FarIsomorphicArgs = WithReturnValue; + +template +void FarIsomorphic(FarIsomorphicArgs *args) { + args->retval = fst::FarIsomorphic( + std::get<0>(args->args), std::get<1>(args->args), std::get<2>(args->args), + std::get<3>(args->args), std::get<4>(args->args)); +} + +bool FarIsomorphic(const string &filename1, const string &filename2, + const string &arc_type, float delta = kDelta, + const string &begin_key = string(), + const string &end_key = string()); + +struct FarPrintStringsArgs { + const std::vector &ifilenames; + const FarEntryType entry_type; + const FarTokenType token_type; + const string &begin_key; + const string &end_key; + const bool print_key; + const bool print_weight; + const string &symbols_fname; + const bool initial_symbols; + const int32 generate_filenames; + const string &filename_prefix; + const string &filename_suffix; + + FarPrintStringsArgs(const std::vector &ifilenames, + const FarEntryType entry_type, + const FarTokenType token_type, const string &begin_key, + const string &end_key, const bool print_key, + const bool print_weight, const string &symbols_fname, + const bool initial_symbols, + const int32 generate_filenames, + const string &filename_prefix, + const string &filename_suffix) + : ifilenames(ifilenames), + entry_type(entry_type), + token_type(token_type), + begin_key(begin_key), + end_key(end_key), + print_key(print_key), + print_weight(print_weight), + symbols_fname(symbols_fname), + initial_symbols(initial_symbols), + generate_filenames(generate_filenames), + filename_prefix(filename_prefix), + filename_suffix(filename_suffix) {} +}; + +template +void FarPrintStrings(FarPrintStringsArgs *args) { + fst::FarPrintStrings( + args->ifilenames, args->entry_type, args->token_type, args->begin_key, + args->end_key, args->print_key, args->print_weight, args->symbols_fname, + args->initial_symbols, args->generate_filenames, args->filename_prefix, + args->filename_suffix); +} + +void FarPrintStrings(const std::vector &ifilenames, + const string &arc_type, const FarEntryType entry_type, + const FarTokenType token_type, const string &begin_key, + const string &end_key, const bool print_key, + const bool print_weight, const string &symbols_fname, + const bool initial_symbols, const int32 generate_filenames, + const string &filename_prefix, + const string &filename_suffix); + +} // namespace script +} // namespace fst + +#define REGISTER_FST_FAR_OPERATIONS(ArcType) \ + REGISTER_FST_OPERATION(FarCompileStrings, ArcType, FarCompileStringsArgs); \ + REGISTER_FST_OPERATION(FarCreate, ArcType, FarCreateArgs); \ + REGISTER_FST_OPERATION(FarEqual, ArcType, FarEqualArgs); \ + REGISTER_FST_OPERATION(FarExtract, ArcType, FarExtractArgs); \ + REGISTER_FST_OPERATION(FarInfo, ArcType, FarInfoArgs); \ + REGISTER_FST_OPERATION(FarIsomorphic, ArcType, FarIsomorphicArgs); \ + REGISTER_FST_OPERATION(FarPrintStrings, ArcType, FarPrintStringsArgs); \ + REGISTER_FST_OPERATION(GetFarInfo, ArcType, GetFarInfoArgs) + +#endif // FST_EXTENSIONS_FAR_FARSCRIPT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/getters.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/getters.h new file mode 100644 index 0000000000..3dde419419 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/getters.h @@ -0,0 +1,30 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Classes and functions for registering and invoking FAR main +// functions that support multiple and extensible arc types. + +#ifndef FST_EXTENSIONS_FAR_GETTERS_H_ +#define FST_EXTENSIONS_FAR_GETTERS_H_ + +#include +#include + +namespace fst { +namespace script { + +FarType GetFarType(const string &str); + +bool GetFarEntryType(const string &str, FarEntryType *entry_type); + +bool GetFarTokenType(const string &str, FarTokenType *token_type); + +void ExpandArgs(int argc, char **argv, int *argcp, char ***argvp); + +} // namespace script + +string GetFarTypeString(FarType type); + +} // namespace fst + +#endif // FST_EXTENSIONS_FAR_GETTERS_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/info.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/info.h new file mode 100644 index 0000000000..0391c1f457 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/info.h @@ -0,0 +1,147 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_EXTENSIONS_FAR_INFO_H_ +#define FST_EXTENSIONS_FAR_INFO_H_ + +#include +#include +#include +#include +#include +#include + +#include +#include + +namespace fst { + +template +void AccumulateStatesAndArcs(const Fst &fst, size_t *nstate, size_t *narc, + size_t *nfinal) { + for (StateIterator> siter(fst); !siter.Done(); + siter.Next(), ++(*nstate)) { + ArcIterator> aiter(fst, siter.Value()); + for (; !aiter.Done(); aiter.Next(), ++(*narc)) { + } + if (fst.Final(siter.Value()) != Arc::Weight::Zero()) ++(*nfinal); + } +} + +struct KeyInfo { + string key; + string type; + size_t nstate = 0; + size_t narc = 0; + size_t nfinal = 0; +}; + +struct FarInfoData { + std::vector key_infos; + string far_type; + string arc_type; + size_t nfst = 0; + size_t nstate = 0; + size_t narc = 0; + size_t nfinal = 0; + std::set fst_types; +}; + +template +void GetFarInfo(const std::vector &filenames, const string &begin_key, + const string &end_key, const bool list_fsts, + FarInfoData *far_info) { + *far_info = FarInfoData(); + std::unique_ptr> reader(FarReader::Open(filenames)); + if (!reader) { + LOG(ERROR) << "GetFarInfo: failed to create far reader."; + return; + } + if (!begin_key.empty()) reader->Find(begin_key); + + for (; !reader->Done(); reader->Next()) { + const auto &key = reader->GetKey(); + if (!end_key.empty() && end_key < key) break; + ++far_info->nfst; + const auto *fst = reader->GetFst(); + far_info->fst_types.insert(fst->Type()); + if (list_fsts) { + KeyInfo info; + info.key = key; + info.type = fst->Type(); + AccumulateStatesAndArcs(*fst, &info.nstate, &info.narc, &info.nfinal); + far_info->nstate += info.nstate; + far_info->narc += info.narc; + far_info->nfinal += info.nfinal; + far_info->key_infos.push_back(info); + } else { + AccumulateStatesAndArcs(*fst, &far_info->nstate, &far_info->narc, + &far_info->nfinal); + } + } + far_info->far_type = GetFarTypeString(reader->Type()); + far_info->arc_type = Arc::Type(); +} + +template +void FarInfo(const std::vector &filenames, const string &begin_key, + const string &end_key, const bool list_fsts) { + FarInfoData info; + GetFarInfo(filenames, begin_key, end_key, list_fsts, &info); + if (!list_fsts) { + std::cout << std::left << std::setw(50) << "far type" << info.far_type + << std::endl; + std::cout << std::left << std::setw(50) << "arc type" << Arc::Type() + << std::endl; + std::cout << std::left << std::setw(50) << "fst type"; + for (auto iter = info.fst_types.begin(); iter != info.fst_types.end(); + ++iter) { + if (iter != info.fst_types.begin()) std::cout << ","; + std::cout << *iter; + } + std::cout << std::endl; + std::cout << std::left << std::setw(50) << "# of FSTs" << info.nfst + << std::endl; + std::cout << std::left << std::setw(50) << "total # of states" + << info.nstate << std::endl; + std::cout << std::left << std::setw(50) << "total # of arcs" << info.narc + << std::endl; + std::cout << std::left << std::setw(50) << "total # of final states" + << info.nfinal << std::endl; + } else { + // FIXME(kbg): Grok, then document this. + int wkey = 10; + int wtype = 10; + int wnstate = 14; + int wnarc = 12; + int wnfinal = 20; + for (const auto &key_info : info.key_infos) { + if (key_info.key.size() + 2 > wkey) wkey = key_info.key.size() + 2; + if (key_info.type.size() + 2 > wtype) wtype = key_info.type.size() + 2; + if (ceil(log10(key_info.nstate)) + 2 > wnstate) { + wnstate = ceil(log10(key_info.nstate)) + 2; + } + if (ceil(log10(key_info.narc)) + 2 > wnarc) { + wnarc = ceil(log10(key_info.narc)) + 2; + } + if (ceil(log10(key_info.nfinal)) + 2 > wnfinal) { + wnfinal = ceil(log10(key_info.nfinal)) + 2; + } + } + std::cout << std::left << std::setw(wkey) << "key" << std::setw(wtype) + << "type" << std::right << std::setw(wnstate) << "# of states" + << std::setw(wnarc) << "# of arcs" << std::setw(wnfinal) + << "# of final states" << std::endl; + for (const auto &key_info : info.key_infos) { + std::cout << std::left << std::setw(wkey) << key_info.key + << std::setw(wtype) << key_info.type << std::right + << std::setw(wnstate) << key_info.nstate << std::setw(wnarc) + << key_info.narc << std::setw(wnfinal) << key_info.nfinal + << std::endl; + } + } +} + +} // namespace fst + +#endif // FST_EXTENSIONS_FAR_INFO_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/isomorphic.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/isomorphic.h new file mode 100644 index 0000000000..1e6e9cb3b7 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/isomorphic.h @@ -0,0 +1,69 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_EXTENSIONS_FAR_ISOMORPHIC_H_ +#define FST_EXTENSIONS_FAR_ISOMORPHIC_H_ + +#include +#include + +#include +#include + +namespace fst { + +template +bool FarIsomorphic(const string &filename1, const string &filename2, + float delta = kDelta, const string &begin_key = string(), + const string &end_key = string()) { + std::unique_ptr> reader1(FarReader::Open(filename1)); + if (!reader1) { + LOG(ERROR) << "FarIsomorphic: Cannot open FAR file " << filename1; + return false; + } + std::unique_ptr> reader2(FarReader::Open(filename2)); + if (!reader2) { + LOG(ERROR) << "FarIsomorphic: Cannot open FAR file " << filename2; + return false; + } + if (!begin_key.empty()) { + bool find_begin1 = reader1->Find(begin_key); + bool find_begin2 = reader2->Find(begin_key); + if (!find_begin1 || !find_begin2) { + bool ret = !find_begin1 && !find_begin2; + if (!ret) { + VLOG(1) << "FarIsomorphic: Key " << begin_key << " missing from " + << (find_begin1 ? "second" : "first") << " archive."; + } + return ret; + } + } + for (; !reader1->Done() && !reader2->Done(); + reader1->Next(), reader2->Next()) { + const auto &key1 = reader1->GetKey(); + const auto &key2 = reader2->GetKey(); + if (!end_key.empty() && end_key < key1 && end_key < key2) return true; + if (key1 != key2) { + LOG(ERROR) << "FarIsomorphic: Mismatched keys " << key1 << " and " + << key2; + return false; + } + if (!Isomorphic(*(reader1->GetFst()), *(reader2->GetFst()), delta)) { + LOG(ERROR) << "FarIsomorphic: FSTs for key " << key1 + << " are not isomorphic"; + return false; + } + } + if (!reader1->Done() || !reader2->Done()) { + LOG(ERROR) << "FarIsomorphic: Key " + << (reader1->Done() ? reader2->GetKey() : reader1->GetKey()) + << " missing form " << (reader2->Done() ? "first" : "second") + << " archive"; + return false; + } + return true; +} + +} // namespace fst + +#endif // FST_EXTENSIONS_FAR_ISOMORPHIC_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/print-strings.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/print-strings.h new file mode 100644 index 0000000000..dc42840159 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/print-strings.h @@ -0,0 +1,105 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Outputs as strings the string FSTs in a finite-state archive. + +#ifndef FST_EXTENSIONS_FAR_PRINT_STRINGS_H_ +#define FST_EXTENSIONS_FAR_PRINT_STRINGS_H_ + +#include +#include +#include + +#include +#include +#include +#include +#include + +DECLARE_string(far_field_separator); + +namespace fst { + +template +void FarPrintStrings(const std::vector &ifilenames, + FarEntryType entry_type, FarTokenType far_token_type, + const string &begin_key, const string &end_key, + bool print_key, bool print_weight, + const string &symbols_fname, bool initial_symbols, + int32 generate_filenames, const string &filename_prefix, + const string &filename_suffix) { + StringTokenType token_type; + if (far_token_type == FTT_SYMBOL) { + token_type = StringTokenType::SYMBOL; + } else if (far_token_type == FTT_BYTE) { + token_type = StringTokenType::BYTE; + } else if (far_token_type == FTT_UTF8) { + token_type = StringTokenType::UTF8; + } else { + FSTERROR() << "FarPrintStrings: Unknown token type"; + return; + } + std::unique_ptr syms; + if (!symbols_fname.empty()) { + // TODO(kbg): Allow negative flag? + const SymbolTableTextOptions opts(true); + syms.reset(SymbolTable::ReadText(symbols_fname, opts)); + if (!syms) { + LOG(ERROR) << "FarPrintStrings: Error reading symbol table " + << symbols_fname; + return; + } + } + std::unique_ptr> far_reader(FarReader::Open(ifilenames)); + if (!far_reader) return; + if (!begin_key.empty()) far_reader->Find(begin_key); + string okey; + int nrep = 0; + for (int i = 1; !far_reader->Done(); far_reader->Next(), ++i) { + const auto &key = far_reader->GetKey(); + if (!end_key.empty() && end_key < key) break; + if (okey == key) { + ++nrep; + } else { + nrep = 0; + } + okey = key; + const auto *fst = far_reader->GetFst(); + if (i == 1 && initial_symbols && !syms && fst->InputSymbols()) + syms.reset(fst->InputSymbols()->Copy()); + string str; + VLOG(2) << "Handling key: " << key; + StringPrinter string_printer(token_type, + syms ? syms.get() : fst->InputSymbols()); + string_printer(*fst, &str); + if (entry_type == FET_LINE) { + if (print_key) std::cout << key << FLAGS_far_field_separator[0]; + std::cout << str; + if (print_weight) + std::cout << FLAGS_far_field_separator[0] << ShortestDistance(*fst); + std::cout << std::endl; + } else if (entry_type == FET_FILE) { + std::stringstream sstrm; + if (generate_filenames) { + sstrm.fill('0'); + sstrm << std::right << std::setw(generate_filenames) << i; + } else { + sstrm << key; + if (nrep > 0) sstrm << "." << nrep; + } + string filename; + filename = filename_prefix + sstrm.str() + filename_suffix; + std::ofstream ostrm(filename); + if (!ostrm) { + LOG(ERROR) << "FarPrintStrings: Can't open file: " << filename; + return; + } + ostrm << str; + if (token_type == StringTokenType::SYMBOL) ostrm << "\n"; + } + } +} + +} // namespace fst + +#endif // FST_EXTENSIONS_FAR_PRINT_STRINGS_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/script-impl.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/script-impl.h new file mode 100644 index 0000000000..a0586cc32a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/script-impl.h @@ -0,0 +1,23 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Classes and functions for registering and invoking Far main +// functions that support multiple and extensible arc types. + +#ifndef FST_EXTENSIONS_FAR_SCRIPT_IMPL_H_ +#define FST_EXTENSIONS_FAR_SCRIPT_IMPL_H_ + +#include + +#include +namespace fst { +namespace script { + +string LoadArcTypeFromFar(const string &far_fname); + +string LoadArcTypeFromFst(const string &fst_fname); + +} // namespace script +} // namespace fst + +#endif // FST_EXTENSIONS_FAR_SCRIPT_IMPL_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/stlist.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/stlist.h new file mode 100644 index 0000000000..fcb80d04a5 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/stlist.h @@ -0,0 +1,267 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// A generic (string,type) list file format. +// +// This is a stripped-down version of STTable that does not support the Find() +// operation but that does support reading/writting from standard in/out. + +#ifndef FST_EXTENSIONS_FAR_STLIST_H_ +#define FST_EXTENSIONS_FAR_STLIST_H_ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +namespace fst { + +static constexpr int32 kSTListMagicNumber = 5656924; +static constexpr int32 kSTListFileVersion = 1; + +// String-type list writing class for object of type T using a functor Writer. +// The Writer functor must provide at least the following interface: +// +// struct Writer { +// void operator()(std::ostream &, const T &) const; +// }; +template +class STListWriter { + public: + explicit STListWriter(const string &filename) + : stream_(filename.empty() ? &std::cout : new std::ofstream( + filename, + std::ios_base::out | + std::ios_base::binary)), + error_(false) { + WriteType(*stream_, kSTListMagicNumber); + WriteType(*stream_, kSTListFileVersion); + if (!stream_) { + FSTERROR() << "STListWriter::STListWriter: Error writing to file: " + << filename; + error_ = true; + } + } + + static STListWriter *Create(const string &filename) { + return new STListWriter(filename); + } + + void Add(const string &key, const T &t) { + if (key == "") { + FSTERROR() << "STListWriter::Add: Key empty: " << key; + error_ = true; + } else if (key < last_key_) { + FSTERROR() << "STListWriter::Add: Key out of order: " << key; + error_ = true; + } + if (error_) return; + last_key_ = key; + WriteType(*stream_, key); + entry_writer_(*stream_, t); + } + + bool Error() const { return error_; } + + ~STListWriter() { + WriteType(*stream_, string()); + if (stream_ != &std::cout) delete stream_; + } + + private: + Writer entry_writer_; + std::ostream *stream_; // Output stream. + string last_key_; // Last key. + bool error_; + + STListWriter(const STListWriter &) = delete; + STListWriter &operator=(const STListWriter &) = delete; +}; + +// String-type list reading class for object of type T using a functor Reader. +// Reader must provide at least the following interface: +// +// struct Reader { +// T *operator()(std::istream &) const; +// }; +template +class STListReader { + public: + explicit STListReader(const std::vector &filenames) + : sources_(filenames), error_(false) { + streams_.resize(filenames.size(), 0); + bool has_stdin = false; + for (size_t i = 0; i < filenames.size(); ++i) { + if (filenames[i].empty()) { + if (!has_stdin) { + streams_[i] = &std::cin; + sources_[i] = "stdin"; + has_stdin = true; + } else { + FSTERROR() << "STListReader::STListReader: Cannot read multiple " + << "inputs from standard input"; + error_ = true; + return; + } + } else { + streams_[i] = new std::ifstream( + filenames[i], std::ios_base::in | std::ios_base::binary); + } + int32 magic_number = 0; + ReadType(*streams_[i], &magic_number); + int32 file_version = 0; + ReadType(*streams_[i], &file_version); + if (magic_number != kSTListMagicNumber) { + FSTERROR() << "STListReader::STListReader: Wrong file type: " + << filenames[i]; + error_ = true; + return; + } + if (file_version != kSTListFileVersion) { + FSTERROR() << "STListReader::STListReader: Wrong file version: " + << filenames[i]; + error_ = true; + return; + } + string key; + ReadType(*streams_[i], &key); + if (!key.empty()) heap_.push(std::make_pair(key, i)); + if (!*streams_[i]) { + FSTERROR() << "STListReader: Error reading file: " << sources_[i]; + error_ = true; + return; + } + } + if (heap_.empty()) return; + const auto current = heap_.top().second; + entry_.reset(entry_reader_(*streams_[current])); + if (!entry_ || !*streams_[current]) { + FSTERROR() << "STListReader: Error reading entry for key " + << heap_.top().first << ", file " << sources_[current]; + error_ = true; + } + } + + ~STListReader() { + for (auto &stream : streams_) { + if (stream != &std::cin) delete stream; + } + } + + static STListReader *Open(const string &filename) { + std::vector filenames; + filenames.push_back(filename); + return new STListReader(filenames); + } + + static STListReader *Open(const std::vector &filenames) { + return new STListReader(filenames); + } + + void Reset() { + FSTERROR() << "STListReader::Reset: Operation not supported"; + error_ = true; + } + + bool Find(const string &key) { + FSTERROR() << "STListReader::Find: Operation not supported"; + error_ = true; + return false; + } + + bool Done() const { return error_ || heap_.empty(); } + + void Next() { + if (error_) return; + auto current = heap_.top().second; + string key; + heap_.pop(); + ReadType(*(streams_[current]), &key); + if (!*streams_[current]) { + FSTERROR() << "STListReader: Error reading file: " << sources_[current]; + error_ = true; + return; + } + if (!key.empty()) heap_.push(std::make_pair(key, current)); + if (!heap_.empty()) { + current = heap_.top().second; + entry_.reset(entry_reader_(*streams_[current])); + if (!entry_ || !*streams_[current]) { + FSTERROR() << "STListReader: Error reading entry for key: " + << heap_.top().first << ", file: " << sources_[current]; + error_ = true; + } + } + } + + const string &GetKey() const { return heap_.top().first; } + + const T *GetEntry() const { return entry_.get(); } + + bool Error() const { return error_; } + + private: + Reader entry_reader_; // Read functor. + std::vector streams_; // Input streams. + std::vector sources_; // Corresponding filenames. + std::priority_queue< + std::pair, std::vector>, + std::greater>> heap_; // (Key, stream id) heap + mutable std::unique_ptr entry_; // The currently read entry. + bool error_; + + STListReader(const STListReader &) = delete; + STListReader &operator=(const STListReader &) = delete; +}; + +// String-type list header reading function, templated on the entry header type. +// The Header type must provide at least the following interface: +// +// struct Header { +// void Read(std::istream &strm, const string &filename); +// }; +template +bool ReadSTListHeader(const string &filename, Header *header) { + if (filename.empty()) { + LOG(ERROR) << "ReadSTListHeader: Can't read header from standard input"; + return false; + } + std::ifstream strm(filename, std::ios_base::in | std::ios_base::binary); + if (!strm) { + LOG(ERROR) << "ReadSTListHeader: Could not open file: " << filename; + return false; + } + int32 magic_number = 0; + ReadType(strm, &magic_number); + int32 file_version = 0; + ReadType(strm, &file_version); + if (magic_number != kSTListMagicNumber) { + LOG(ERROR) << "ReadSTListHeader: Wrong file type: " << filename; + return false; + } + if (file_version != kSTListFileVersion) { + LOG(ERROR) << "ReadSTListHeader: Wrong file version: " << filename; + return false; + } + string key; + ReadType(strm, &key); + header->Read(strm, filename + ":" + key); + if (!strm) { + LOG(ERROR) << "ReadSTListHeader: Error reading file: " << filename; + return false; + } + return true; +} + +bool IsSTList(const string &filename); + +} // namespace fst + +#endif // FST_EXTENSIONS_FAR_STLIST_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/sttable.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/sttable.h new file mode 100644 index 0000000000..41f3475e43 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/far/sttable.h @@ -0,0 +1,347 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// A generic string-to-type table file format. +// +// This is not meant as a generalization of SSTable. This is more of a simple +// replacement for SSTable in order to provide an open-source implementation +// of the FAR format for the external version of the FST library. + +#ifndef FST_EXTENSIONS_FAR_STTABLE_H_ +#define FST_EXTENSIONS_FAR_STTABLE_H_ + +#include +#include +#include + +#include +#include + +namespace fst { + +static constexpr int32 kSTTableMagicNumber = 2125656924; +static constexpr int32 kSTTableFileVersion = 1; + +// String-type table writing class for an object of type T using a functor +// Writer. The Writer functor must provide at least the following interface: +// +// struct Writer { +// void operator()(std::ostream &, const T &) const; +// }; +template +class STTableWriter { + public: + explicit STTableWriter(const string &filename) + : stream_(filename, std::ios_base::out | std::ios_base::binary), + error_(false) { + WriteType(stream_, kSTTableMagicNumber); + WriteType(stream_, kSTTableFileVersion); + if (stream_.fail()) { + FSTERROR() << "STTableWriter::STTableWriter: Error writing to file: " + << filename; + error_ = true; + } + } + + static STTableWriter *Create(const string &filename) { + if (filename.empty()) { + LOG(ERROR) << "STTableWriter: Writing to standard out unsupported."; + return nullptr; + } + return new STTableWriter(filename); + } + + void Add(const string &key, const T &t) { + if (key == "") { + FSTERROR() << "STTableWriter::Add: Key empty: " << key; + error_ = true; + } else if (key < last_key_) { + FSTERROR() << "STTableWriter::Add: Key out of order: " << key; + error_ = true; + } + if (error_) return; + last_key_ = key; + positions_.push_back(stream_.tellp()); + WriteType(stream_, key); + entry_writer_(stream_, t); + } + + bool Error() const { return error_; } + + ~STTableWriter() { + WriteType(stream_, positions_); + WriteType(stream_, static_cast(positions_.size())); + } + + private: + Writer entry_writer_; + std::ofstream stream_; + std::vector positions_; // Position in file of each key-entry pair. + string last_key_; // Last key. + bool error_; + + STTableWriter(const STTableWriter &) = delete; + STTableWriter &operator=(const STTableWriter &) = delete; +}; + +// String-type table reading class for object of type T using a functor Reader. +// Reader must provide at least the following interface: +// +// struct Reader { +// T *operator()(std::istream &) const; +// }; +// +template +class STTableReader { + public: + explicit STTableReader(const std::vector &filenames) + : sources_(filenames), error_(false) { + compare_.reset(new Compare(&keys_)); + keys_.resize(filenames.size()); + streams_.resize(filenames.size(), 0); + positions_.resize(filenames.size()); + for (size_t i = 0; i < filenames.size(); ++i) { + streams_[i] = new std::ifstream( + filenames[i], std::ios_base::in | std::ios_base::binary); + int32 magic_number = 0; + ReadType(*streams_[i], &magic_number); + int32 file_version = 0; + ReadType(*streams_[i], &file_version); + if (magic_number != kSTTableMagicNumber) { + FSTERROR() << "STTableReader::STTableReader: Wrong file type: " + << filenames[i]; + error_ = true; + return; + } + if (file_version != kSTTableFileVersion) { + FSTERROR() << "STTableReader::STTableReader: Wrong file version: " + << filenames[i]; + error_ = true; + return; + } + int64 num_entries; + streams_[i]->seekg(-static_cast(sizeof(int64)), std::ios_base::end); + ReadType(*streams_[i], &num_entries); + if (num_entries > 0) { + streams_[i]->seekg(-static_cast(sizeof(int64)) * (num_entries + 1), + std::ios_base::end); + positions_[i].resize(num_entries); + for (size_t j = 0; (j < num_entries) && (!streams_[i]->fail()); ++j) { + ReadType(*streams_[i], &(positions_[i][j])); + } + streams_[i]->seekg(positions_[i][0]); + if (streams_[i]->fail()) { + FSTERROR() << "STTableReader::STTableReader: Error reading file: " + << filenames[i]; + error_ = true; + return; + } + } + } + MakeHeap(); + } + + ~STTableReader() { + for (auto &stream : streams_) delete stream; + } + + static STTableReader *Open(const string &filename) { + if (filename.empty()) { + LOG(ERROR) << "STTableReader: Operation not supported on standard input"; + return nullptr; + } + std::vector filenames; + filenames.push_back(filename); + return new STTableReader(filenames); + } + + static STTableReader *Open(const std::vector &filenames) { + return new STTableReader(filenames); + } + + void Reset() { + if (error_) return; + for (size_t i = 0; i < streams_.size(); ++i) + streams_[i]->seekg(positions_[i].front()); + MakeHeap(); + } + + bool Find(const string &key) { + if (error_) return false; + for (size_t i = 0; i < streams_.size(); ++i) LowerBound(i, key); + MakeHeap(); + if (heap_.empty()) return false; + return keys_[current_] == key; + } + + bool Done() const { return error_ || heap_.empty(); } + + void Next() { + if (error_) return; + if (streams_[current_]->tellg() <= positions_[current_].back()) { + ReadType(*(streams_[current_]), &(keys_[current_])); + if (streams_[current_]->fail()) { + FSTERROR() << "STTableReader: Error reading file: " + << sources_[current_]; + error_ = true; + return; + } + std::push_heap(heap_.begin(), heap_.end(), *compare_); + } else { + heap_.pop_back(); + } + if (!heap_.empty()) PopHeap(); + } + + const string &GetKey() const { return keys_[current_]; } + + const T *GetEntry() const { return entry_.get(); } + + bool Error() const { return error_; } + + private: + // Comparison functor used to compare stream IDs in the heap. + struct Compare { + explicit Compare(const std::vector *keys) : keys(keys) {} + + bool operator()(size_t i, size_t j) const { + return (*keys)[i] > (*keys)[j]; + }; + + private: + const std::vector *keys; + }; + + // Positions the stream at the position corresponding to the lower bound for + // the specified key. + void LowerBound(size_t id, const string &find_key) { + auto *strm = streams_[id]; + const auto &positions = positions_[id]; + if (positions.empty()) return; + size_t low = 0; + size_t high = positions.size() - 1; + while (low < high) { + size_t mid = (low + high) / 2; + strm->seekg(positions[mid]); + string key; + ReadType(*strm, &key); + if (key > find_key) { + high = mid; + } else if (key < find_key) { + low = mid + 1; + } else { + for (size_t i = mid; i > low; --i) { + strm->seekg(positions[i - 1]); + ReadType(*strm, &key); + if (key != find_key) { + strm->seekg(positions[i]); + return; + } + } + strm->seekg(positions[low]); + return; + } + } + strm->seekg(positions[low]); + } + + // Adds all streams to the heap. + void MakeHeap() { + heap_.clear(); + for (size_t i = 0; i < streams_.size(); ++i) { + if (positions_[i].empty()) continue; + ReadType(*streams_[i], &(keys_[i])); + if (streams_[i]->fail()) { + FSTERROR() << "STTableReader: Error reading file: " << sources_[i]; + error_ = true; + return; + } + heap_.push_back(i); + } + if (heap_.empty()) return; + std::make_heap(heap_.begin(), heap_.end(), *compare_); + PopHeap(); + } + + // Positions the stream with the lowest key at the top of the heap, sets + // current_ to the ID of that stream, and reads the current entry from that + // stream. + void PopHeap() { + std::pop_heap(heap_.begin(), heap_.end(), *compare_); + current_ = heap_.back(); + entry_.reset(entry_reader_(*streams_[current_])); + if (!entry_) error_ = true; + if (streams_[current_]->fail()) { + FSTERROR() << "STTableReader: Error reading entry for key: " + << keys_[current_] << ", file: " << sources_[current_]; + error_ = true; + } + } + + Reader entry_reader_; + std::vector streams_; // Input streams. + std::vector sources_; // Corresponding file names. + std::vector> positions_; // Index of positions. + std::vector keys_; // Lowest unread key for each stream. + std::vector heap_; // Heap containing ID of streams with unread keys. + int64 current_; // ID of current stream to be read. + std::unique_ptr compare_; // Functor comparing stream IDs. + mutable std::unique_ptr entry_; // The currently read entry. + bool error_; +}; + +// String-type table header reading function template on the entry header type. +// The Header type must provide at least the following interface: +// +// struct Header { +// void Read(std::istream &istrm, const string &filename); +// }; +template +bool ReadSTTableHeader(const string &filename, Header *header) { + if (filename.empty()) { + LOG(ERROR) << "ReadSTTable: Can't read header from standard input"; + return false; + } + std::ifstream strm(filename, std::ios_base::in | std::ios_base::binary); + if (!strm) { + LOG(ERROR) << "ReadSTTableHeader: Could not open file: " << filename; + return false; + } + int32 magic_number = 0; + ReadType(strm, &magic_number); + int32 file_version = 0; + ReadType(strm, &file_version); + if (magic_number != kSTTableMagicNumber) { + LOG(ERROR) << "ReadSTTableHeader: Wrong file type: " << filename; + return false; + } + if (file_version != kSTTableFileVersion) { + LOG(ERROR) << "ReadSTTableHeader: Wrong file version: " << filename; + return false; + } + int64 i = -1; + strm.seekg(-static_cast(sizeof(int64)), std::ios_base::end); + ReadType(strm, &i); // Reads number of entries + if (strm.fail()) { + LOG(ERROR) << "ReadSTTableHeader: Error reading file: " << filename; + return false; + } + if (i == 0) return true; // No entry header to read. + strm.seekg(-2 * static_cast(sizeof(int64)), std::ios_base::end); + ReadType(strm, &i); // Reads position for last entry in file. + strm.seekg(i); + string key; + ReadType(strm, &key); + header->Read(strm, filename + ":" + key); + if (strm.fail()) { + LOG(ERROR) << "ReadSTTableHeader: Error reading file: " << filename; + return false; + } + return true; +} + +bool IsSTTable(const string &filename); + +} // namespace fst + +#endif // FST_EXTENSIONS_FAR_STTABLE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/linear/linear-fst-data-builder.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/linear/linear-fst-data-builder.h new file mode 100644 index 0000000000..a6ac727971 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/linear/linear-fst-data-builder.h @@ -0,0 +1,1074 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_EXTENSIONS_LINEAR_LINEAR_FST_DATA_BUILDER_H_ +#define FST_EXTENSIONS_LINEAR_LINEAR_FST_DATA_BUILDER_H_ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include + +namespace fst { + +// Forward declaration +template +class FeatureGroupBuilder; + +// For logging purposes +inline string TranslateLabel(int64 label, const SymbolTable *syms); +template +string JoinLabels(Iterator begin, Iterator end, const SymbolTable *syms); +template +string JoinLabels(const std::vector *Dump(); + + private: + bool error_; + CompactSet all_output_labels_; + std::map> word_output_map_, word_feat_map_; + std::map> feat_groups_; + std::vector>> groups_; + size_t max_future_size_; + Label max_input_label_; + const SymbolTable *isyms_, *fsyms_, *osyms_; + + LinearFstDataBuilder(const LinearFstDataBuilder &) = delete; + LinearFstDataBuilder &operator=(const LinearFstDataBuilder &) = delete; +}; + +// Builds a LinearFstData tailored for a LinearClassifierFst. The +// major difference between an ordinary LinearFstData that works on +// taggers and a LinearFstData that works on classifiers is that +// feature groups are divided into sections by the prediction class +// label. For a prediction label `pred` and a logical group id +// `group`, the actual group id is `group * num_classes + pred - +// 1`. +// +// This layout saves us from recording output labels in each single +// FeatureGroup. Because there is no need for any delaying, stripping +// the output allows features with different shapes but using the same +// set of feature label mapping to reside in a single FeatureGroup. +template +class LinearClassifierFstDataBuilder { + public: + typedef typename A::Label Label; + typedef typename A::Weight Weight; + + // Constructs a builder for a `num_classes`-class classifier, + // optinally with associated symbol tables for diagnostic + // output. The output labels (i.e. prediction) must be in the range + // of [1, num_classes]. + explicit LinearClassifierFstDataBuilder(size_t num_classes, + const SymbolTable *isyms = nullptr, + const SymbolTable *fsyms = nullptr, + const SymbolTable *osyms = nullptr) + : error_(false), + num_classes_(num_classes), + num_groups_(0), + builder_(isyms, fsyms, osyms) {} + + // Tests whether the builder has encountered any error. Similar to + // LinearFstDataBuilder<>::Error(). + bool Error() const { return error_; } + + // Same as LinearFstDataBuilder<>::AddWord(). + bool AddWord(Label word, const std::vector *Dump(); + + private: + std::vector builder_; +}; + +// Builds a single feature group. Usually used in +// `LinearFstDataBuilder::AddWeight()`. See that method for the +// constraints on grouping features. +template +class FeatureGroupBuilder { + public: + typedef typename A::Label Label; + typedef typename A::Weight Weight; + + // Constructs a builder with the given future size. All features + // added to the group will have look-ahead windows of this size. + FeatureGroupBuilder(size_t future_size, const SymbolTable *fsyms, + const SymbolTable *osyms) + : error_(false), future_size_(future_size), fsyms_(fsyms), osyms_(osyms) { + // This edge is special; see doc of class `FeatureGroup` on the + // details. + start_ = trie_.Insert(trie_.Root(), InputOutputLabel(kNoLabel, kNoLabel)); + } + + // Tests whether the builder has encountered any error. No operation + // is valid if the builder is already at error state. All other + // public methods should check this before any actual operations. + bool Error() const { return error_; } + + // Adds a feature weight with the given context. Returns true iff + // the weight is added. A weight is not added if it has ill-formed + // context involving start-, end-of-sentence marks. + // + // Note: `input` is the sequence of input + // features, instead of input labels themselves. `input` must be at + // least as long as `future_size`; `output` may be empty, but + // usually should be non-empty because an empty output context is + // useless in discriminative modelling. All labels in both `input` + // and `output` must be > 0 (this is checked in + // `LinearFstDataBuilder::AddWeight()`). See + // LinearFstDataBuilder<>::AddWeight for more details. + // + // This may fail if the input is smaller than the look-ahead window. + bool AddWeight(const std::vector *Dump(size_t max_future_size); + + private: + typedef typename FeatureGroup::InputOutputLabel InputOutputLabel; + typedef typename FeatureGroup::InputOutputLabelHash InputOutputLabelHash; + typedef typename FeatureGroup::WeightBackLink WeightBackLink; + // Nested trie topology uses more memory but we can traverse a + // node's children easily, which is required in `BuildBackLinks()`. + typedef NestedTrieTopology Topology; + typedef MutableTrie Trie; + + // Finds the first node with an arc with `label` following the + // back-off chain of `parent`. Returns the node index or + // `kNoTrieNodeId` when not found. The number of hops is stored in + // `hop` when it is not `nullptr`. + // + // This does not fail. + int FindFirstMatch(InputOutputLabel label, int parent, int *hop) const; + + // Links each node to its immediate back-off. root is linked to -1. + // + // This may fail when the unique immediate back-off constraint is + // violated. + void BuildBackLinks(); + + // Traces back on the back-chain for each node to multiply the + // weights from back-offs to the node itself. + // + // This does not fail. + void PreAccumulateWeights(); + + // Reconstruct the path from trie root to given node for logging. + bool TrieDfs(const Topology &topology, int cur, int target, + std::vector *path) const; + string TriePath(int node, const Topology &topology) const; + + bool error_; + size_t future_size_; + Trie trie_; + int start_; + const SymbolTable *fsyms_, *osyms_; + + FeatureGroupBuilder(const FeatureGroupBuilder &) = delete; + FeatureGroupBuilder &operator=(const FeatureGroupBuilder &) = delete; +}; + +// +// Implementation of methods in `LinearFstDataBuilder` +// +template +bool LinearFstDataBuilder::AddWord(Label word, + const std::vector::kStartOfSentence || + word == LinearFstData::kEndOfSentence) { + LOG(WARNING) << "Ignored: adding boundary label: " + << TranslateLabel(word, isyms_) + << "(start-of-sentence=" << LinearFstData::kStartOfSentence + << ", end-of-sentence=" << LinearFstData::kEndOfSentence + << ")"; + return false; + } + if (word <= 0) { + error_ = true; + FSTERROR() << "Word label must be > 0; got " << word; + return false; + } + if (word > max_input_label_) max_input_label_ = word; + // Make sure the word hasn't been added before + if (word_feat_map_.find(word) != word_feat_map_.end()) { + error_ = true; + FSTERROR() << "Input word " << TranslateLabel(word, isyms_) + << " is added twice"; + return false; + } + // Store features + std::set::AddWord( + Label word, const std::vector::kStartOfSentence || + output == LinearFstData::kEndOfSentence) { + LOG(WARNING) << "Ignored: word = " << TranslateLabel(word, isyms_) + << ": adding boundary label as possible output: " << output + << "(start-of-sentence=" + << LinearFstData::kStartOfSentence + << ", end-of-sentence=" << LinearFstData::kEndOfSentence + << ")"; + continue; + } + if (output <= 0) { + error_ = true; + FSTERROR() << "Output label must be > 0; got " << output; + return false; + } + outputs->insert(output); + all_output_labels_.Insert(output); + } + return true; +} + +template +inline int LinearFstDataBuilder::AddGroup(size_t future_size) { + if (error_) { + FSTERROR() << "Calling LinearFstDataBuilder<>::AddGroup() at error state"; + return -1; + } + size_t ret = groups_.size(); + groups_.emplace_back(new FeatureGroupBuilder(future_size, fsyms_, osyms_)); + if (future_size > max_future_size_) max_future_size_ = future_size; + return ret; +} + +template +bool LinearFstDataBuilder::AddWeight(size_t group, + const std::vector::kStartOfSentence && + input[i - 1] != LinearFstData::kStartOfSentence) + start_in_middle = true; + if (input[i - 1] == LinearFstData::kEndOfSentence && + input[i] != LinearFstData::kEndOfSentence) + end_in_middle = true; + } + if (start_in_middle) { + LOG(WARNING) << "Ignored: start-of-sentence in the middle of the input!"; + LOG(WARNING) << "\tInput: " << JoinLabels(input, fsyms_); + LOG(WARNING) << "\tOutput: " << JoinLabels(output, osyms_); + return false; + } + if (end_in_middle) { + LOG(WARNING) << "Ignored: end-of-sentence in the middle of the input!"; + LOG(WARNING) << "\tInput: " << JoinLabels(input, fsyms_); + LOG(WARNING) << "\tOutput: " << JoinLabels(output, osyms_); + return false; + } + } + // Check well-formedness of boundary marks on the output. + { + bool non_first_start = false, non_last_end = false; + for (int i = 1; i < output.size(); ++i) { + if (output[i] == LinearFstData::kStartOfSentence) + non_first_start = true; + if (output[i - 1] == LinearFstData::kEndOfSentence) + non_last_end = true; + } + if (non_first_start) { + LOG(WARNING) << "Ignored: start-of-sentence not appearing " + << "as the first label in the output!"; + LOG(WARNING) << "\tInput: " << JoinLabels(input, fsyms_); + LOG(WARNING) << "\tOutput: " << JoinLabels(output, osyms_); + return false; + } + if (non_last_end) { + LOG(WARNING) << "Ignored: end-of-sentence not appearing " + << "as the last label in the output!"; + LOG(WARNING) << "\tInput: " << JoinLabels(input, fsyms_); + LOG(WARNING) << "\tOutput: " << JoinLabels(output, osyms_); + return false; + } + } + + for (size_t i = 0; i < input.size(); ++i) { + Label feat = input[i]; + if (feat != LinearFstData::kStartOfSentence && + feat != LinearFstData::kEndOfSentence && feat <= 0) { + error_ = true; + FSTERROR() << "Feature label must be > 0; got " << feat; + return false; + } + feat_groups_[feat].insert(group); + } + for (size_t i = 0; i < output.size(); ++i) { + Label label = output[i]; + if (label != LinearFstData::kStartOfSentence && + label != LinearFstData::kEndOfSentence && label <= 0) { + error_ = true; + FSTERROR() << "Output label must be > 0; got " << label; + return false; + } + if (label != LinearFstData::kStartOfSentence && + label != LinearFstData::kEndOfSentence) + all_output_labels_.Insert(label); + } + + // Everything looks good at this point (more checks on the way in + // the feature group). Add this feature weight. + bool added = groups_[group]->AddWeight(input, output, weight); + if (groups_[group]->Error()) { + error_ = true; + FSTERROR() << "FeatureGroupBuilder<>::AddWeight() failed"; + return false; + } + return added; +} + +template +LinearFstData *LinearFstDataBuilder::Dump() { + if (error_) { + FSTERROR() << "Calling LinearFstDataBuilder<>::Dump() at error state"; + return nullptr; + } + + std::unique_ptr> data(new LinearFstData()); + data->max_future_size_ = max_future_size_; + data->max_input_label_ = max_input_label_; + + // Feature groups; free builders after it's dumped. + data->groups_.resize(groups_.size()); + for (int group = 0; group != groups_.size(); ++group) { + FeatureGroup *new_group = groups_[group]->Dump(max_future_size_); + if (new_group == nullptr) { + error_ = true; + FSTERROR() << "Error in dumping group " << group; + return nullptr; + } + data->groups_[group].reset(new_group); + groups_[group].reset(); + VLOG(1) << "Group " << group << ": " << new_group->Stats(); + } + + // Per-group feature mapping + data->group_feat_map_.Init(data->NumGroups(), max_input_label_ + 1); + for (Label word = 1; word <= max_input_label_; ++word) { + typename std::map>::const_iterator it = + word_feat_map_.find(word); + if (it == word_feat_map_.end()) continue; + for (typename std::set::AddWord( + Label word, const std::vector::AddGroup() { + if (error_) { + FSTERROR() << "Calling LinearClassifierFstDataBuilder<>::AddGroup() at " + "error state"; + return -1; + } + for (int i = 0; i < num_classes_; ++i) builder_.AddGroup(0); + if (builder_.Error()) { + error_ = true; + return -1; + } + return num_groups_++; +} + +template +inline bool LinearClassifierFstDataBuilder::AddWeight( + size_t group, const std::vector *LinearClassifierFstDataBuilder::Dump() { + if (error_) { + FSTERROR() + << "Calling LinearClassifierFstDataBuilder<>::Dump() at error state"; + return nullptr; + } + LinearFstData *data = builder_.Dump(); + error_ = true; + return data; +} + +// +// Implementation of methods in `FeatureGroupBuilder` +// +template +bool FeatureGroupBuilder::AddWeight(const std::vector::kStartOfSentence) + ++num_input_start; + int num_output_start = 0; + while (num_output_start < output.size() && + output[num_output_start] == LinearFstData::kStartOfSentence) + ++num_output_start; + int num_input_end = 0; + for (int i = input.size() - 1; + i >= 0 && input[i] == LinearFstData::kEndOfSentence; --i) + ++num_input_end; + int num_output_end = 0; + for (int i = output.size() - 1; + i >= 0 && output[i] == LinearFstData::kEndOfSentence; --i) + ++num_output_end; + + DCHECK_LE(num_output_end, 1); + + if (input.size() - num_input_start < future_size_) { + LOG(WARNING) << "Ignored: start-of-sentence in the future!"; + LOG(WARNING) << "\tInput: " << JoinLabels(input, fsyms_); + LOG(WARNING) << "\tOutput: " << JoinLabels(output, fsyms_); + return false; + } + if (num_input_start > 0 && + input.size() - future_size_ - num_input_start < + output.size() - num_output_start) { + LOG(WARNING) << "Ignored: matching start-of-sentence with actual output!"; + LOG(WARNING) << "\tInput: " << JoinLabels(input, fsyms_); + LOG(WARNING) << "\tOutput: " << JoinLabels(output, osyms_); + return false; + } + if (num_output_start > 0 && + input.size() - future_size_ - num_input_start > + output.size() - num_output_start) { + LOG(WARNING) << "Ignored: matching start-of-sentence with actual input!"; + LOG(WARNING) << "\tInput: " << JoinLabels(input, fsyms_); + LOG(WARNING) << "\tOutput: " << JoinLabels(output, osyms_); + return false; + } + // The following two require `num_output_end` <= 1. + if (num_input_end > future_size_ && num_input_end - future_size_ != 1) { + LOG(WARNING) << "Ignored: matching end-of-sentence with actual output!"; + LOG(WARNING) << "\tInput: " << JoinLabels(input, fsyms_); + LOG(WARNING) << "\tOutput: " << JoinLabels(output, osyms_); + return false; + } + if (num_output_end > 0 && + ((input.size() == future_size_ && future_size_ != num_input_end) || + (input.size() > future_size_ && + num_input_end != future_size_ + num_output_end))) { + LOG(WARNING) << "Ignored: matching end-of-sentence with actual input!"; + LOG(WARNING) << "\tInput: " << JoinLabels(input, fsyms_); + LOG(WARNING) << "\tOutput: " << JoinLabels(output, osyms_); + return false; + } + // Check if the context has no other labels than boundary marks + // (such features are useless). + if (num_input_start + num_input_end == input.size() && + num_output_start + num_output_end == output.size()) { + LOG(WARNING) + << "Ignored: feature context consisting of only boundary marks!"; + LOG(WARNING) << "\tInput: " << JoinLabels(input, fsyms_); + LOG(WARNING) << "\tOutput: " << JoinLabels(output, osyms_); + return false; + } + + // Start point for insertion in the trie. Insert at `start_` iff the + // beginning of the context is non-consumed start-of-sentence. + int cur = (num_input_start == 0 && num_output_start <= future_size_) + ? trie_.Root() + : start_; + // Skip all input start-of-sentence marks + size_t ipos = num_input_start; + // Skip to keep at most `future_size_` start-of-sentence marks + size_t opos = + num_output_start <= future_size_ ? 0 : num_output_start - future_size_; + // Skip `num_output_end` end-of-sentence marks on both input and output + size_t iend = !input.empty() ? input.size() - num_output_end : 0, + oend = output.size() - num_output_end; + // Further, when output is empty, keep at most `future_size_` + // end-of-sentence marks on input. + if (output.empty() && num_input_end > future_size_) + iend = input.size() - num_input_end + future_size_; + + // Actual feature context is (input[ipos:iend], output[opos:oend]). + + // Pad `kNoLabel` as don't cares on the shorter of actual `input` + // and `output`. + const size_t effective_input_size = iend - ipos, + effective_output_size = oend - opos; + if (effective_input_size > effective_output_size) { + for (size_t pad = effective_input_size - effective_output_size; pad != 0; + --pad, ++ipos) + cur = trie_.Insert(cur, InputOutputLabel(input[ipos], kNoLabel)); + } else if (effective_input_size < effective_output_size) { + for (size_t pad = effective_output_size - effective_input_size; pad != 0; + --pad, ++opos) + cur = trie_.Insert(cur, InputOutputLabel(kNoLabel, output[opos])); + } + CHECK_EQ(iend - ipos, oend - opos); + for (; ipos != iend; ++ipos, ++opos) + cur = trie_.Insert(cur, InputOutputLabel(input[ipos], output[opos])); + // We only need to attach final weight when there is an output + // end-of-sentence. When there is only end-of-sentence on the input, + // they are all consumed as the end-of-sentence paddings from + // `LinearFstImpl<>::ShiftBuffer()`. `LinearFstImpl<>::Expand()` + // and `LinearFstImpl<>::MatchInput()` ensures no other + // transition takes place after consuming the padding. + if (num_output_end > 0 || (output.empty() && num_input_end > future_size_)) + trie_[cur].final_weight = Times(trie_[cur].final_weight, weight); + else + trie_[cur].weight = Times(trie_[cur].weight, weight); + + return true; +} + +template +FeatureGroup *FeatureGroupBuilder::Dump(size_t max_future_size) { + if (error_) { + FSTERROR() << "Calling FeatureGroupBuilder<>::PreAccumulateWeights() " + << "at error state"; + return nullptr; + } + + if (max_future_size < future_size_) { + error_ = true; + FSTERROR() << "max_future_size (= " << max_future_size + << ") is smaller the builder's future_size (= " << future_size_ + << ")"; + return nullptr; + } + + BuildBackLinks(); + if (error_) return nullptr; + PreAccumulateWeights(); // does not fail + + FeatureGroup *ret = + new FeatureGroup(max_future_size - future_size_, start_); + + // Walk around the trie to compute next states + ret->next_state_.resize(trie_.NumNodes()); + const Topology &topology = trie_.TrieTopology(); + for (int i = 0; i < topology.NumNodes(); ++i) { + int next = i; + while (next != topology.Root() && topology.ChildrenOf(next).empty() && + trie_[next].final_weight == + trie_[trie_[next].back_link].final_weight) + next = trie_[next].back_link; + ret->next_state_[i] = next; + } + + // Copy the trie + typename FeatureGroup::Trie store_trie(trie_); + ret->trie_.swap(store_trie); + + // Put the builder at error state to prevent repeated call of `Dump()`. + error_ = true; + return ret; +} + +template +int FeatureGroupBuilder::FindFirstMatch(InputOutputLabel label, int parent, + int *hop) const { + int hop_count = 0; + int ret = kNoTrieNodeId; + for (; parent >= 0; parent = trie_[parent].back_link, ++hop_count) { + int next = trie_.Find(parent, label); + if (next != kNoTrieNodeId) { + ret = next; + break; + } + } + if (hop != nullptr) *hop = hop_count; + return ret; +} + +template +void FeatureGroupBuilder::BuildBackLinks() { + // Breadth first search from the root. In the case where we only + // have the input label, the immedate back-off is simply the longest + // suffix of the current node that is also in the trie. For a node + // reached from its parent with label L, we can simply walk through + // the parent's back-off chain to find the first state with an arc + // of the same label L. The uniqueness is always + // guanranteed. However, in the case with both input and output + // labels, it is possible to back off by removing first labels from + // either side, which in general causes non-uniqueness. + + const Topology &topology = trie_.TrieTopology(); + std::queue q; // all enqueued or visited nodes have known links + + // Note: nodes have back link initialized to -1 in their + // constructor. + q.push(trie_.Root()); + while (!error_ && !q.empty()) { + int parent = q.front(); + q.pop(); + // Find links for every child + const typename Topology::NextMap &children = topology.ChildrenOf(parent); + for (typename Topology::NextMap::const_iterator eit = children.begin(); + eit != children.end(); ++eit) { + const std::pair &edge = *eit; + InputOutputLabel label = edge.first; + int child = edge.second; + if (label.input == kNoLabel || label.output == kNoLabel) { + // Label pairs from root to here all have one and only one + // `kNoLabel` on the same side; equivalent to the + // "longest-suffix" case. + trie_[child].back_link = + FindFirstMatch(label, trie_[parent].back_link, nullptr); + } else { + // Neither side is `kNoLabel` at this point, there are + // three possible ways to back-off: if the parent backs + // off to some context with only one side non-empty, the + // empty side may remain empty; or else an exact match of + // both sides is needed. Try to find all three possible + // backs and look for the closest one (in terms of hops + // along the parent's back-off chain). + int only_input_hop, only_output_hop, full_hop; + int only_input_link = + FindFirstMatch(InputOutputLabel(label.input, kNoLabel), parent, + &only_input_hop), + only_output_link = + FindFirstMatch(InputOutputLabel(kNoLabel, label.output), parent, + &only_output_hop), + full_link = + FindFirstMatch(label, trie_[parent].back_link, &full_hop); + if (only_input_link != -1 && only_output_link != -1) { + error_ = true; + FSTERROR() << "Branching back-off chain:\n" + << "\tnode " << child << ": " << TriePath(child, topology) + << "\n" + << "\tcan back-off to node " << only_input_link << ": " + << TriePath(only_input_link, topology) << "\n" + << "\tcan back-off to node " << only_output_link << ": " + << TriePath(only_output_link, topology); + return; + } else if (full_link != -1) { + ++full_hop; + if (full_hop <= only_input_hop && full_hop <= only_output_hop) { + trie_[child].back_link = full_link; + } else { + error_ = true; + int problem_link = only_input_link != kNoTrieNodeId + ? only_input_link + : only_output_link; + CHECK_NE(problem_link, kNoTrieNodeId); + FSTERROR() << "Branching back-off chain:\n" + << "\tnode " << child << ": " + << TriePath(child, topology) << "\n" + << "\tcan back-off to node " << full_link << ": " + << TriePath(full_link, topology) << "\n" + << "tcan back-off to node " << problem_link << ": " + << TriePath(problem_link, topology); + return; + } + } else { + trie_[child].back_link = + only_input_link != -1 ? only_input_link : only_output_link; + } + } + if (error_) break; + // Point to empty context (root) when no back-off can be found + if (trie_[child].back_link == -1) trie_[child].back_link = 0; + q.push(child); + } + } +} + +template +void FeatureGroupBuilder::PreAccumulateWeights() { + std::vector visited(trie_.NumNodes(), false); + visited[trie_.Root()] = true; + + for (size_t i = 0; i != trie_.NumNodes(); ++i) { + std::stack back_offs; + for (int j = i; !visited[j]; j = trie_[j].back_link) back_offs.push(j); + while (!back_offs.empty()) { + int j = back_offs.top(); + back_offs.pop(); + WeightBackLink &node = trie_[j]; + node.weight = Times(node.weight, trie_[node.back_link].weight); + node.final_weight = + Times(node.final_weight, trie_[node.back_link].final_weight); + visited[j] = true; + } + } +} + +template +bool FeatureGroupBuilder::TrieDfs( + const Topology &topology, int cur, int target, + std::vector *path) const { + if (cur == target) return true; + const typename Topology::NextMap &children = topology.ChildrenOf(cur); + for (typename Topology::NextMap::const_iterator eit = children.begin(); + eit != children.end(); ++eit) { + const std::pair &edge = *eit; + path->push_back(edge.first); + if (TrieDfs(topology, edge.second, target, path)) return true; + path->pop_back(); + } + return false; +} + +template +string FeatureGroupBuilder::TriePath(int node, + const Topology &topology) const { + std::vector labels; + TrieDfs(topology, topology.Root(), node, &labels); + bool first = true; + std::ostringstream strm; + for (typename std::vector::const_iterator it = + labels.begin(); + it != labels.end(); ++it) { + InputOutputLabel i = *it; + if (first) + first = false; + else + strm << ", "; + strm << "(" << TranslateLabel(i.input, fsyms_) << ", " + << TranslateLabel(i.output, osyms_) << ")"; + } + return strm.str(); +} + +inline string TranslateLabel(int64 label, const SymbolTable *syms) { + string ret; + if (syms != nullptr) ret += syms->Find(label); + if (ret.empty()) { + std::ostringstream strm; + strm << '<' << label << '>'; + ret = strm.str(); + } + return ret; +} + +template +string JoinLabels(Iterator begin, Iterator end, const SymbolTable *syms) { + if (begin == end) return ""; + std::ostringstream strm; + bool first = true; + for (Iterator it = begin; it != end; ++it) { + if (first) + first = false; + else + strm << '|'; + strm << TranslateLabel(*it, syms); + } + return strm.str(); +} + +template +string JoinLabels(const std::vector::kStartOfSentence; + } else if (left && !right) { + // Can only be end + (*sequence)[i] = LinearFstData::kEndOfSentence; + } else if (!left && right) { + // Can only be start + (*sequence)[i] = LinearFstData::kStartOfSentence; + } else { + // !left && !right; can't really tell + ++unresolved; + } + } + return unresolved; +} + +} // namespace fst + +#endif // FST_EXTENSIONS_LINEAR_LINEAR_FST_DATA_BUILDER_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/linear/linear-fst-data.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/linear/linear-fst-data.h new file mode 100644 index 0000000000..3b39c29d9a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/linear/linear-fst-data.h @@ -0,0 +1,526 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Data structures for storing and looking up the actual feature weights. + +#ifndef FST_EXTENSIONS_LINEAR_LINEAR_FST_DATA_H_ +#define FST_EXTENSIONS_LINEAR_LINEAR_FST_DATA_H_ + +#include +#include +#include +#include +#include + +#include +#include + +#include + +namespace fst { + +// Forward declarations +template +class LinearFstDataBuilder; +template +class FeatureGroup; + +// Immutable data storage of the feature weights in a linear +// model. Produces state tuples that represent internal states of a +// LinearTaggerFst. Object of this class can only be constructed via +// either `LinearFstDataBuilder::Dump()` or `LinearFstData::Read()` +// and usually used as refcount'd object shared across mutiple +// `LinearTaggerFst` copies. +// +// TODO(wuke): more efficient trie implementation +template +class LinearFstData { + public: + friend class LinearFstDataBuilder; // For builder access + + typedef typename A::Label Label; + typedef typename A::Weight Weight; + + // Sentence boundary labels. Both of them are negative labels other + // than `kNoLabel`. + static const Label kStartOfSentence; + static const Label kEndOfSentence; + + // Constructs empty data; for non-trivial ways of construction see + // `Read()` and `LinearFstDataBuilder`. + LinearFstData() + : max_future_size_(0), max_input_label_(1), input_attribs_(1) {} + + // Appends the state tuple of the start state to `output`, where + // each tuple holds the node ids of a trie for each feature group. + void EncodeStartState(std::vector *Read(std::istream &strm); // NOLINT + std::ostream &Write(std::ostream &strm) const; // NOLINT + + private: + // Offsets in `output_pool_` + struct InputAttribute { + size_t output_begin, output_length; + + std::istream &Read(std::istream &strm); // NOLINT + std::ostream &Write(std::ostream &strm) const; // NOLINT + }; + + // Mapping from input label to per-group feature label + class GroupFeatureMap; + + // Translates the input label into input feature label of group + // `group`; returns `kNoLabel` when there is no feature for that + // group. + Label FindFeature(size_t group, Label word) const; + + size_t max_future_size_; + Label max_input_label_; + std::vector>> groups_; + std::vector input_attribs_; + std::vector::kStartOfSentence = -3; +template +const typename A::Label LinearFstData::kEndOfSentence = -2; + +template +template +void LinearFstData::TakeTransition(Iterator buffer_end, + Iterator trie_state_begin, + Iterator trie_state_end, Label ilabel, + Label olabel, std::vector::GroupTransition(int group_id, + int trie_state, + Label ilabel, Label olabel, + Weight *weight) const { + Label group_ilabel = FindFeature(group_id, ilabel); + return groups_[group_id]->Walk(trie_state, group_ilabel, olabel, weight); +} + +template +template +inline typename A::Weight LinearFstData::FinalWeight( + Iterator trie_state_begin, Iterator trie_state_end) const { + DCHECK_EQ(trie_state_end - trie_state_begin, groups_.size()); + size_t group_id = 0; + Weight accum = Weight::One(); + for (Iterator it = trie_state_begin; it != trie_state_end; ++it, ++group_id) + accum = Times(accum, GroupFinalWeight(group_id, *it)); + return accum; +} + +template +inline std::pair::const_iterator, + typename std::vector::const_iterator> +LinearFstData::PossibleOutputLabels(Label word) const { + const InputAttribute &attrib = input_attribs_[word]; + if (attrib.output_length == 0) + return std::make_pair(output_set_.begin(), output_set_.end()); + else + return std::make_pair( + output_pool_.begin() + attrib.output_begin, + output_pool_.begin() + attrib.output_begin + attrib.output_length); +} + +template +inline LinearFstData *LinearFstData::Read(std::istream &strm) { // NOLINT + std::unique_ptr> data(new LinearFstData()); + ReadType(strm, &(data->max_future_size_)); + ReadType(strm, &(data->max_input_label_)); + // Feature groups + size_t num_groups = 0; + ReadType(strm, &num_groups); + data->groups_.resize(num_groups); + for (size_t i = 0; i < num_groups; ++i) + data->groups_[i].reset(FeatureGroup::Read(strm)); + // Other data + ReadType(strm, &(data->input_attribs_)); + ReadType(strm, &(data->output_pool_)); + ReadType(strm, &(data->output_set_)); + ReadType(strm, &(data->group_feat_map_)); + if (strm) { + return data.release(); + } else { + return nullptr; + } +} + +template +inline std::ostream &LinearFstData::Write( + std::ostream &strm) const { // NOLINT + WriteType(strm, max_future_size_); + WriteType(strm, max_input_label_); + // Feature groups + WriteType(strm, groups_.size()); + for (size_t i = 0; i < groups_.size(); ++i) { + groups_[i]->Write(strm); + } + // Other data + WriteType(strm, input_attribs_); + WriteType(strm, output_pool_); + WriteType(strm, output_set_); + WriteType(strm, group_feat_map_); + return strm; +} + +template +typename A::Label LinearFstData::FindFeature(size_t group, + Label word) const { + DCHECK(word > 0 || word == kStartOfSentence || word == kEndOfSentence); + if (word == kStartOfSentence || word == kEndOfSentence) + return word; + else + return group_feat_map_.Find(group, word); +} + +template +inline std::istream &LinearFstData::InputAttribute::Read( + std::istream &strm) { // NOLINT + ReadType(strm, &output_begin); + ReadType(strm, &output_length); + return strm; +} + +template +inline std::ostream &LinearFstData::InputAttribute::Write( + std::ostream &strm) const { // NOLINT + WriteType(strm, output_begin); + WriteType(strm, output_length); + return strm; +} + +// Forward declaration +template +class FeatureGroupBuilder; + +// An immutable grouping of features with similar context shape. Like +// `LinearFstData`, this can only be constructed via `Read()` or +// via its builder. +// +// Internally it uses a trie to store all feature n-grams and their +// weights. The label of a trie edge is a pair (feat, olabel) of +// labels. They can be either positive (ordinary label), `kNoLabel`, +// `kStartOfSentence`, or `kEndOfSentence`. `kNoLabel` usually means +// matching anything, with one exception: from the root of the trie, +// there is a special (kNoLabel, kNoLabel) that leads to the implicit +// start-of-sentence state. This edge is never actually matched +// (`FindFirstMatch()` ensures this). +template +class FeatureGroup { + public: + friend class FeatureGroupBuilder; // for builder access + + typedef typename A::Label Label; + typedef typename A::Weight Weight; + + int Start() const { return start_; } + + // Finds destination node from `cur` by consuming `ilabel` and + // `olabel`. The transition weight is multiplied onto `weight`. + int Walk(int cur, Label ilabel, Label olabel, Weight *weight) const; + + // Returns the final weight of the current trie state. Only valid if + // the state is already known to be part of a final state (see + // `LinearFstData<>::CanBeFinal()`). + Weight FinalWeight(int trie_state) const { + return trie_[trie_state].final_weight; + } + + static FeatureGroup *Read(std::istream &strm) { // NOLINT + size_t delay; + ReadType(strm, &delay); + int start; + ReadType(strm, &start); + Trie trie; + ReadType(strm, &trie); + std::unique_ptr> ret(new FeatureGroup(delay, start)); + ret->trie_.swap(trie); + ReadType(strm, &ret->next_state_); + if (strm) { + return ret.release(); + } else { + return nullptr; + } + } + + std::ostream &Write(std::ostream &strm) const { // NOLINT + WriteType(strm, delay_); + WriteType(strm, start_); + WriteType(strm, trie_); + WriteType(strm, next_state_); + return strm; + } + + size_t Delay() const { return delay_; } + + string Stats() const; + + private: + // Label along the arcs on the trie. `kNoLabel` means anything + // (non-negative label) can match; both sides holding `kNoLabel` + // is not allow; otherwise the label is > 0 (enforced by + // `LinearFstDataBuilder::AddWeight()`). + struct InputOutputLabel; + struct InputOutputLabelHash; + + // Data to be stored on the trie + struct WeightBackLink { + int back_link; + Weight weight, final_weight; + + WeightBackLink() + : back_link(kNoTrieNodeId), + weight(Weight::One()), + final_weight(Weight::One()) {} + + std::istream &Read(std::istream &strm) { // NOLINT + ReadType(strm, &back_link); + ReadType(strm, &weight); + ReadType(strm, &final_weight); + return strm; + } + + std::ostream &Write(std::ostream &strm) const { // NOLINT + WriteType(strm, back_link); + WriteType(strm, weight); + WriteType(strm, final_weight); + return strm; + } + }; + + typedef FlatTrieTopology Topology; + typedef MutableTrie Trie; + + explicit FeatureGroup(size_t delay, int start) + : delay_(delay), start_(start) {} + + // Finds the first node with an arc with `label` following the + // back-off chain of `parent`. Returns the node index or + // `kNoTrieNodeId` when not found. + int FindFirstMatch(InputOutputLabel label, int parent) const; + + size_t delay_; + int start_; + Trie trie_; + // Where to go after hitting this state. When we reach a state with + // no child and with no additional final weight (i.e. its final + // weight is the same as its back-off), we can immediately go to its + // back-off state. + std::vector next_state_; + + FeatureGroup(const FeatureGroup &) = delete; + FeatureGroup &operator=(const FeatureGroup &) = delete; +}; + +template +struct FeatureGroup::InputOutputLabel { + Label input, output; + + InputOutputLabel(Label i = kNoLabel, Label o = kNoLabel) + : input(i), output(o) {} + + bool operator==(InputOutputLabel that) const { + return input == that.input && output == that.output; + } + + std::istream &Read(std::istream &strm) { // NOLINT + ReadType(strm, &input); + ReadType(strm, &output); + return strm; + } + + std::ostream &Write(std::ostream &strm) const { // NOLINT + WriteType(strm, input); + WriteType(strm, output); + return strm; + } +}; + +template +struct FeatureGroup::InputOutputLabelHash { + size_t operator()(InputOutputLabel label) const { + return static_cast(label.input * 7853 + label.output); + } +}; + +template +int FeatureGroup::Walk(int cur, Label ilabel, Label olabel, + Weight *weight) const { + // Note: user of this method need to ensure `ilabel` and `olabel` + // are valid (e.g. see DCHECKs in + // `LinearFstData<>::TakeTransition()` and + // `LinearFstData<>::FindFeature()`). + int next; + if (ilabel == LinearFstData::kStartOfSentence) { + // An observed start-of-sentence only occurs in the beginning of + // the input, when this feature group is delayed (i.e. there is + // another feature group with a larger future size). The actual + // input hasn't arrived so stay at the start state. + DCHECK_EQ(cur, start_); + next = start_; + } else { + // First, try exact match + next = FindFirstMatch(InputOutputLabel(ilabel, olabel), cur); + // Then try with don't cares + if (next == kNoTrieNodeId) + next = FindFirstMatch(InputOutputLabel(ilabel, kNoLabel), cur); + if (next == kNoTrieNodeId) + next = FindFirstMatch(InputOutputLabel(kNoLabel, olabel), cur); + // All failed, go to empty context + if (next == kNoTrieNodeId) next = trie_.Root(); + *weight = Times(*weight, trie_[next].weight); + next = next_state_[next]; + } + return next; +} + +template +inline int FeatureGroup::FindFirstMatch(InputOutputLabel label, + int parent) const { + if (label.input == kNoLabel && label.output == kNoLabel) + return kNoTrieNodeId; // very important; see class doc. + for (; parent != kNoTrieNodeId; parent = trie_[parent].back_link) { + int next = trie_.Find(parent, label); + if (next != kNoTrieNodeId) return next; + } + return kNoTrieNodeId; +} + +template +inline string FeatureGroup::Stats() const { + std::ostringstream strm; + int num_states = 2; + for (int i = 2; i < next_state_.size(); ++i) + num_states += i == next_state_[i]; + strm << trie_.NumNodes() << " node(s); " << num_states << " state(s)"; + return strm.str(); +} + +template +class LinearFstData::GroupFeatureMap { + public: + GroupFeatureMap() {} + + void Init(size_t num_groups, size_t num_words) { + num_groups_ = num_groups; + pool_.clear(); + pool_.resize(num_groups * num_words, kNoLabel); + } + + Label Find(size_t group_id, Label ilabel) const { + return pool_[IndexOf(group_id, ilabel)]; + } + + bool Set(size_t group_id, Label ilabel, Label feat) { + size_t i = IndexOf(group_id, ilabel); + if (pool_[i] != kNoLabel && pool_[i] != feat) { + FSTERROR() << "Feature group " << group_id + << " already has feature for word " << ilabel; + return false; + } + pool_[i] = feat; + return true; + } + + std::istream &Read(std::istream &strm) { // NOLINT + ReadType(strm, &num_groups_); + ReadType(strm, &pool_); + return strm; + } + + std::ostream &Write(std::ostream &strm) const { // NOLINT + WriteType(strm, num_groups_); + WriteType(strm, pool_); + return strm; + } + + private: + size_t IndexOf(size_t group_id, Label ilabel) const { + return ilabel * num_groups_ + group_id; + } + + size_t num_groups_; + // `pool_[ilabel * num_groups_ + group_id]` is the feature active + // for group `group_id` with input `ilabel` + std::vector { + public: + using FstImpl::SetType; + using FstImpl::SetProperties; + using FstImpl::SetInputSymbols; + using FstImpl::SetOutputSymbols; + using FstImpl::WriteHeader; + + using CacheBaseImpl>::PushArc; + using CacheBaseImpl>::HasArcs; + using CacheBaseImpl>::HasFinal; + using CacheBaseImpl>::HasStart; + using CacheBaseImpl>::SetArcs; + using CacheBaseImpl>::SetFinal; + using CacheBaseImpl>::SetStart; + + typedef A Arc; + typedef typename A::Label Label; + typedef typename A::Weight Weight; + typedef typename A::StateId StateId; + typedef typename Collection::SetIterator NGramIterator; + + // Constructs an empty FST by default. + LinearTaggerFstImpl() + : CacheImpl(CacheOptions()), + data_(std::make_shared>()), + delay_(0) { + SetType("linear-tagger"); + } + + // Constructs the FST with given data storage and symbol + // tables. + // + // TODO(wuke): when there is no constraint on output we can delay + // less than `data->MaxFutureSize` positions. + LinearTaggerFstImpl(const LinearFstData *data, const SymbolTable *isyms, + const SymbolTable *osyms, CacheOptions opts) + : CacheImpl(opts), data_(data), delay_(data->MaxFutureSize()) { + SetType("linear-tagger"); + SetProperties(kILabelSorted, kFstProperties); + SetInputSymbols(isyms); + SetOutputSymbols(osyms); + ReserveStubSpace(); + } + + // Copy by sharing the underlying data storage. + LinearTaggerFstImpl(const LinearTaggerFstImpl &impl) + : CacheImpl(impl), data_(impl.data_), delay_(impl.delay_) { + SetType("linear-tagger"); + SetProperties(impl.Properties(), kCopyProperties); + SetInputSymbols(impl.InputSymbols()); + SetOutputSymbols(impl.OutputSymbols()); + ReserveStubSpace(); + } + + StateId Start() { + if (!HasStart()) { + StateId start = FindStartState(); + SetStart(start); + } + return CacheImpl::Start(); + } + + Weight Final(StateId s) { + if (!HasFinal(s)) { + state_stub_.clear(); + FillState(s, &state_stub_); + if (CanBeFinal(state_stub_)) + SetFinal(s, data_->FinalWeight(InternalBegin(state_stub_), + InternalEnd(state_stub_))); + else + SetFinal(s, Weight::Zero()); + } + return CacheImpl::Final(s); + } + + size_t NumArcs(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumArcs(s); + } + + size_t NumInputEpsilons(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumInputEpsilons(s); + } + + size_t NumOutputEpsilons(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumOutputEpsilons(s); + } + + void InitArcIterator(StateId s, ArcIteratorData *data) { + if (!HasArcs(s)) Expand(s); + CacheImpl::InitArcIterator(s, data); + } + + // Computes the outgoing transitions from a state, creating new + // destination states as needed. + void Expand(StateId s); + + // Appends to `arcs` all out-going arcs from state `s` that matches `label` as + // the input label. + void MatchInput(StateId s, Label ilabel, std::vector *arcs); + + static LinearTaggerFstImpl *Read(std::istream &strm, + const FstReadOptions &opts); + + bool Write(std::ostream &strm, // NOLINT + const FstWriteOptions &opts) const { + FstHeader header; + header.SetStart(kNoStateId); + WriteHeader(strm, opts, kFileVersion, &header); + data_->Write(strm); + if (!strm) { + LOG(ERROR) << "LinearTaggerFst::Write: Write failed: " << opts.source; + return false; + } + return true; + } + + private: + static const int kMinFileVersion; + static const int kFileVersion; + + // A collection of functions to access parts of the state tuple. A + // state tuple is a vector of `Label`s with two parts: + // [buffer] [internal]. + // + // - [buffer] is a buffer of observed input labels with length + // `delay_`. `LinearFstData::kStartOfSentence` + // (resp. `LinearFstData::kEndOfSentence`) are used as + // paddings when the buffer has fewer than `delay_` elements, which + // can only appear as the prefix (resp. suffix) of the buffer. + // + // - [internal] is the internal state tuple for `LinearFstData` + typename std::vector::kStartOfSentence); + // Append internal states + data_->EncodeStartState(&state_stub_); + return FindState(state_stub_); + } + + // Tests whether the buffer in `(begin, end)` is empty. + bool IsEmptyBuffer(typename std::vector::kEndOfSentence => + // buffer[i+x] == LinearFstData::kEndOfSentence + // - buffer[i] == LinearFstData::kStartOfSentence => + // buffer[i-x] == LinearFstData::kStartOfSentence + return delay_ == 0 || *(end - 1) == LinearFstData::kStartOfSentence || + *begin == LinearFstData::kEndOfSentence; + } + + // Tests whether the given state tuple can be a final state. A state + // is final iff there is no observed input in the buffer. + bool CanBeFinal(const std::vector::kMinFileVersion = 1; + +template +const int LinearTaggerFstImpl::kFileVersion = 1; + +template +inline typename A::Label LinearTaggerFstImpl::ShiftBuffer( + const std::vector::kEndOfSentence); + if (delay_ == 0) { + DCHECK_GT(ilabel, 0); + return ilabel; + } else { + (*next_stub_)[BufferEnd(*next_stub_) - next_stub_->begin() - 1] = ilabel; + return *BufferBegin(state); + } +} + +template +inline A LinearTaggerFstImpl::MakeArc(const std::vector::kEndOfSentence); + DCHECK(olabel > 0 || olabel == LinearFstData::kStartOfSentence); + Weight weight(Weight::One()); + data_->TakeTransition(BufferEnd(state), InternalBegin(state), + InternalEnd(state), ilabel, olabel, next_stub_, + &weight); + StateId nextstate = FindState(*next_stub_); + // Restore `next_stub_` to its size before the call + next_stub_->resize(delay_); + // In the actual arc, we use epsilons instead of boundaries. + return A(ilabel == LinearFstData::kEndOfSentence ? 0 : ilabel, + olabel == LinearFstData::kStartOfSentence ? 0 : olabel, weight, + nextstate); +} + +template +inline void LinearTaggerFstImpl::ExpandArcs(StateId s, + const std::vector::kStartOfSentence) { + // This happens when input is shorter than `delay_`. + PushArc(s, MakeArc(state, ilabel, LinearFstData::kStartOfSentence, + next_stub_)); + } else { + std::pair::const_iterator, + typename std::vector::const_iterator> range = + data_->PossibleOutputLabels(obs_ilabel); + for (typename std::vector::const_iterator it = + range.first; + it != range.second; ++it) + PushArc(s, MakeArc(state, ilabel, *it, next_stub_)); + } +} + +// TODO(wuke): this has much in duplicate with `ExpandArcs()` +template +inline void LinearTaggerFstImpl::AppendArcs(StateId /*s*/, + const std::vector::kStartOfSentence) { + // This happens when input is shorter than `delay_`. + arcs->push_back( + MakeArc(state, ilabel, LinearFstData::kStartOfSentence, next_stub_)); + } else { + std::pair::const_iterator, + typename std::vector::const_iterator> range = + data_->PossibleOutputLabels(obs_ilabel); + for (typename std::vector::const_iterator it = + range.first; + it != range.second; ++it) + arcs->push_back(MakeArc(state, ilabel, *it, next_stub_)); + } +} + +template +void LinearTaggerFstImpl::Expand(StateId s) { + VLOG(3) << "Expand " << s; + state_stub_.clear(); + FillState(s, &state_stub_); + + // Precompute the first `delay_ - 1` elements in the buffer of + // next states, which are identical for different input/output. + next_stub_.clear(); + next_stub_.resize(delay_); + if (delay_ > 0) + std::copy(BufferBegin(state_stub_) + 1, BufferEnd(state_stub_), + next_stub_.begin()); + + // Epsilon transition for flushing out the next observed input + if (!IsEmptyBuffer(BufferBegin(state_stub_), BufferEnd(state_stub_))) + ExpandArcs(s, state_stub_, LinearFstData::kEndOfSentence, &next_stub_); + + // Non-epsilon input when we haven't flushed + if (delay_ == 0 || + *(BufferEnd(state_stub_) - 1) != LinearFstData::kEndOfSentence) + for (Label ilabel = data_->MinInputLabel(); + ilabel <= data_->MaxInputLabel(); ++ilabel) + ExpandArcs(s, state_stub_, ilabel, &next_stub_); + + SetArcs(s); +} + +template +void LinearTaggerFstImpl::MatchInput(StateId s, Label ilabel, + std::vector *arcs) { + state_stub_.clear(); + FillState(s, &state_stub_); + + // Precompute the first `delay_ - 1` elements in the buffer of + // next states, which are identical for different input/output. + next_stub_.clear(); + next_stub_.resize(delay_); + if (delay_ > 0) + std::copy(BufferBegin(state_stub_) + 1, BufferEnd(state_stub_), + next_stub_.begin()); + + if (ilabel == 0) { + // Epsilon transition for flushing out the next observed input + if (!IsEmptyBuffer(BufferBegin(state_stub_), BufferEnd(state_stub_))) + AppendArcs(s, state_stub_, LinearFstData::kEndOfSentence, &next_stub_, + arcs); + } else { + // Non-epsilon input when we haven't flushed + if (delay_ == 0 || + *(BufferEnd(state_stub_) - 1) != LinearFstData::kEndOfSentence) + AppendArcs(s, state_stub_, ilabel, &next_stub_, arcs); + } +} + +template +inline LinearTaggerFstImpl *LinearTaggerFstImpl::Read( + std::istream &strm, const FstReadOptions &opts) { // NOLINT + std::unique_ptr> impl(new LinearTaggerFstImpl()); + FstHeader header; + if (!impl->ReadHeader(strm, opts, kMinFileVersion, &header)) { + return nullptr; + } + impl->data_ = std::shared_ptr>(LinearFstData::Read(strm)); + if (!impl->data_) { + return nullptr; + } + impl->delay_ = impl->data_->MaxFutureSize(); + impl->ReserveStubSpace(); + return impl.release(); +} + +} // namespace internal + +// This class attaches interface to implementation and handles +// reference counting, delegating most methods to ImplToFst. +template +class LinearTaggerFst : public ImplToFst> { + public: + friend class ArcIterator>; + friend class StateIterator>; + friend class LinearFstMatcherTpl>; + + typedef A Arc; + typedef typename A::Label Label; + typedef typename A::Weight Weight; + typedef typename A::StateId StateId; + typedef DefaultCacheStore Store; + typedef typename Store::State State; + using Impl = internal::LinearTaggerFstImpl; + + LinearTaggerFst() : ImplToFst(std::make_shared()) {} + + explicit LinearTaggerFst(LinearFstData *data, + const SymbolTable *isyms = nullptr, + const SymbolTable *osyms = nullptr, + CacheOptions opts = CacheOptions()) + : ImplToFst(std::make_shared(data, isyms, osyms, opts)) {} + + explicit LinearTaggerFst(const Fst &fst) + : ImplToFst(std::make_shared()) { + LOG(FATAL) << "LinearTaggerFst: no constructor from arbitrary FST."; + } + + // See Fst<>::Copy() for doc. + LinearTaggerFst(const LinearTaggerFst &fst, bool safe = false) + : ImplToFst(fst, safe) {} + + // Get a copy of this LinearTaggerFst. See Fst<>::Copy() for further doc. + LinearTaggerFst *Copy(bool safe = false) const override { + return new LinearTaggerFst(*this, safe); + } + + inline void InitStateIterator(StateIteratorData *data) const override; + + void InitArcIterator(StateId s, ArcIteratorData *data) const override { + GetMutableImpl()->InitArcIterator(s, data); + } + + MatcherBase *InitMatcher(MatchType match_type) const override { + return new LinearFstMatcherTpl>(this, match_type); + } + + static LinearTaggerFst *Read(const string &filename) { + if (!filename.empty()) { + std::ifstream strm(filename, + std::ios_base::in | std::ios_base::binary); + if (!strm) { + LOG(ERROR) << "LinearTaggerFst::Read: Can't open file: " << filename; + return nullptr; + } + return Read(strm, FstReadOptions(filename)); + } else { + return Read(std::cin, FstReadOptions("standard input")); + } + } + + static LinearTaggerFst *Read(std::istream &in, // NOLINT + const FstReadOptions &opts) { + auto *impl = Impl::Read(in, opts); + return impl ? new LinearTaggerFst(std::shared_ptr(impl)) : nullptr; + } + + bool Write(const string &filename) const override { + if (!filename.empty()) { + std::ofstream strm(filename, + std::ios_base::out | std::ios_base::binary); + if (!strm) { + LOG(ERROR) << "LinearTaggerFst::Write: Can't open file: " << filename; + return false; + } + return Write(strm, FstWriteOptions(filename)); + } else { + return Write(std::cout, FstWriteOptions("standard output")); + } + } + + bool Write(std::ostream &strm, const FstWriteOptions &opts) const override { + return GetImpl()->Write(strm, opts); + } + + private: + using ImplToFst::GetImpl; + using ImplToFst::GetMutableImpl; + + explicit LinearTaggerFst(std::shared_ptr impl) + : ImplToFst(impl) {} + + void operator=(const LinearTaggerFst &fst) = delete; +}; + +// Specialization for LinearTaggerFst. +template +class StateIterator> + : public CacheStateIterator> { + public: + explicit StateIterator(const LinearTaggerFst &fst) + : CacheStateIterator>(fst, fst.GetMutableImpl()) {} +}; + +// Specialization for LinearTaggerFst. +template +class ArcIterator> + : public CacheArcIterator> { + public: + using StateId = typename Arc::StateId; + + ArcIterator(const LinearTaggerFst &fst, StateId s) + : CacheArcIterator>(fst.GetMutableImpl(), s) { + if (!fst.GetImpl()->HasArcs(s)) fst.GetMutableImpl()->Expand(s); + } +}; + +template +inline void LinearTaggerFst::InitStateIterator( + StateIteratorData *data) const { + data->base = new StateIterator>(*this); +} + +namespace internal { + +// Implementation class for on-the-fly generated LinearClassifierFst with +// special optimization in matching. +template +class LinearClassifierFstImpl : public CacheImpl { + public: + using FstImpl::SetType; + using FstImpl::SetProperties; + using FstImpl::SetInputSymbols; + using FstImpl::SetOutputSymbols; + using FstImpl::WriteHeader; + + using CacheBaseImpl>::PushArc; + using CacheBaseImpl>::HasArcs; + using CacheBaseImpl>::HasFinal; + using CacheBaseImpl>::HasStart; + using CacheBaseImpl>::SetArcs; + using CacheBaseImpl>::SetFinal; + using CacheBaseImpl>::SetStart; + + typedef A Arc; + typedef typename A::Label Label; + typedef typename A::Weight Weight; + typedef typename A::StateId StateId; + typedef typename Collection::SetIterator NGramIterator; + + // Constructs an empty FST by default. + LinearClassifierFstImpl() + : CacheImpl(CacheOptions()), + data_(std::make_shared>()) { + SetType("linear-classifier"); + num_classes_ = 0; + num_groups_ = 0; + } + + // Constructs the FST with given data storage, number of classes and + // symbol tables. + LinearClassifierFstImpl(const LinearFstData *data, size_t num_classes, + const SymbolTable *isyms, const SymbolTable *osyms, + CacheOptions opts) + : CacheImpl(opts), + data_(data), + num_classes_(num_classes), + num_groups_(data_->NumGroups() / num_classes_) { + SetType("linear-classifier"); + SetProperties(kILabelSorted, kFstProperties); + SetInputSymbols(isyms); + SetOutputSymbols(osyms); + ReserveStubSpace(); + } + + // Copy by sharing the underlying data storage. + LinearClassifierFstImpl(const LinearClassifierFstImpl &impl) + : CacheImpl(impl), + data_(impl.data_), + num_classes_(impl.num_classes_), + num_groups_(impl.num_groups_) { + SetType("linear-classifier"); + SetProperties(impl.Properties(), kCopyProperties); + SetInputSymbols(impl.InputSymbols()); + SetOutputSymbols(impl.OutputSymbols()); + ReserveStubSpace(); + } + + StateId Start() { + if (!HasStart()) { + StateId start = FindStartState(); + SetStart(start); + } + return CacheImpl::Start(); + } + + Weight Final(StateId s) { + if (!HasFinal(s)) { + state_stub_.clear(); + FillState(s, &state_stub_); + SetFinal(s, FinalWeight(state_stub_)); + } + return CacheImpl::Final(s); + } + + size_t NumArcs(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumArcs(s); + } + + size_t NumInputEpsilons(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumInputEpsilons(s); + } + + size_t NumOutputEpsilons(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumOutputEpsilons(s); + } + + void InitArcIterator(StateId s, ArcIteratorData *data) { + if (!HasArcs(s)) Expand(s); + CacheImpl::InitArcIterator(s, data); + } + + // Computes the outgoing transitions from a state, creating new + // destination states as needed. + void Expand(StateId s); + + // Appends to `arcs` all out-going arcs from state `s` that matches + // `label` as the input label. + void MatchInput(StateId s, Label ilabel, std::vector *arcs); + + static LinearClassifierFstImpl *Read(std::istream &strm, + const FstReadOptions &opts); + + bool Write(std::ostream &strm, const FstWriteOptions &opts) const { + FstHeader header; + header.SetStart(kNoStateId); + WriteHeader(strm, opts, kFileVersion, &header); + data_->Write(strm); + WriteType(strm, num_classes_); + if (!strm) { + LOG(ERROR) << "LinearClassifierFst::Write: Write failed: " << opts.source; + return false; + } + return true; + } + + private: + static const int kMinFileVersion; + static const int kFileVersion; + + // A collection of functions to access parts of the state tuple. A + // state tuple is a vector of `Label`s with two parts: + // [prediction] [internal]. + // + // - [prediction] is a single label of the predicted class. A state + // must have a positive class label, unless it is the start state. + // + // - [internal] is the internal state tuple for `LinearFstData` of + // the given class; or kNoTrieNodeId's if in start state. + Label &Prediction(std::vector &) = delete; +}; + +template +const int LinearClassifierFstImpl::kMinFileVersion = 0; + +template +const int LinearClassifierFstImpl::kFileVersion = 0; + +template +void LinearClassifierFstImpl::Expand(StateId s) { + VLOG(3) << "Expand " << s; + state_stub_.clear(); + FillState(s, &state_stub_); + next_stub_.clear(); + next_stub_.resize(1 + num_groups_); + + if (IsStartState(state_stub_)) { + // Make prediction + for (Label pred = 1; pred <= num_classes_; ++pred) { + Prediction(next_stub_) = pred; + for (int i = 0; i < num_groups_; ++i) + InternalAt(next_stub_, i) = data_->GroupStartState(GroupId(pred, i)); + PushArc(s, A(0, pred, Weight::One(), FindState(next_stub_))); + } + } else { + Label pred = Prediction(state_stub_); + DCHECK_GT(pred, 0); + DCHECK_LE(pred, num_classes_); + for (Label ilabel = data_->MinInputLabel(); + ilabel <= data_->MaxInputLabel(); ++ilabel) { + Prediction(next_stub_) = pred; + Weight weight = Weight::One(); + for (int i = 0; i < num_groups_; ++i) + InternalAt(next_stub_, i) = + data_->GroupTransition(GroupId(pred, i), InternalAt(state_stub_, i), + ilabel, pred, &weight); + PushArc(s, A(ilabel, 0, weight, FindState(next_stub_))); + } + } + + SetArcs(s); +} + +template +void LinearClassifierFstImpl::MatchInput(StateId s, Label ilabel, + std::vector *arcs) { + state_stub_.clear(); + FillState(s, &state_stub_); + next_stub_.clear(); + next_stub_.resize(1 + num_groups_); + + if (IsStartState(state_stub_)) { + // Make prediction if `ilabel` is epsilon. + if (ilabel == 0) { + for (Label pred = 1; pred <= num_classes_; ++pred) { + Prediction(next_stub_) = pred; + for (int i = 0; i < num_groups_; ++i) + InternalAt(next_stub_, i) = data_->GroupStartState(GroupId(pred, i)); + arcs->push_back(A(0, pred, Weight::One(), FindState(next_stub_))); + } + } + } else if (ilabel != 0) { + Label pred = Prediction(state_stub_); + Weight weight = Weight::One(); + Prediction(next_stub_) = pred; + for (int i = 0; i < num_groups_; ++i) + InternalAt(next_stub_, i) = data_->GroupTransition( + GroupId(pred, i), InternalAt(state_stub_, i), ilabel, pred, &weight); + arcs->push_back(A(ilabel, 0, weight, FindState(next_stub_))); + } +} + +template +inline LinearClassifierFstImpl *LinearClassifierFstImpl::Read( + std::istream &strm, const FstReadOptions &opts) { + std::unique_ptr> impl( + new LinearClassifierFstImpl()); + FstHeader header; + if (!impl->ReadHeader(strm, opts, kMinFileVersion, &header)) { + return nullptr; + } + impl->data_ = std::shared_ptr>(LinearFstData::Read(strm)); + if (!impl->data_) { + return nullptr; + } + ReadType(strm, &impl->num_classes_); + if (!strm) { + return nullptr; + } + impl->num_groups_ = impl->data_->NumGroups() / impl->num_classes_; + if (impl->num_groups_ * impl->num_classes_ != impl->data_->NumGroups()) { + FSTERROR() << "Total number of feature groups is not a multiple of the " + "number of classes: num groups = " + << impl->data_->NumGroups() + << ", num classes = " << impl->num_classes_; + return nullptr; + } + impl->ReserveStubSpace(); + return impl.release(); +} + +} // namespace internal + +// This class attaches interface to implementation and handles +// reference counting, delegating most methods to ImplToFst. +template +class LinearClassifierFst + : public ImplToFst> { + public: + friend class ArcIterator>; + friend class StateIterator>; + friend class LinearFstMatcherTpl>; + + typedef A Arc; + typedef typename A::Label Label; + typedef typename A::Weight Weight; + typedef typename A::StateId StateId; + typedef DefaultCacheStore Store; + typedef typename Store::State State; + using Impl = internal::LinearClassifierFstImpl; + + LinearClassifierFst() : ImplToFst(std::make_shared()) {} + + explicit LinearClassifierFst(LinearFstData *data, size_t num_classes, + const SymbolTable *isyms = nullptr, + const SymbolTable *osyms = nullptr, + CacheOptions opts = CacheOptions()) + : ImplToFst( + std::make_shared(data, num_classes, isyms, osyms, opts)) {} + + explicit LinearClassifierFst(const Fst &fst) + : ImplToFst(std::make_shared()) { + LOG(FATAL) << "LinearClassifierFst: no constructor from arbitrary FST."; + } + + // See Fst<>::Copy() for doc. + LinearClassifierFst(const LinearClassifierFst &fst, bool safe = false) + : ImplToFst(fst, safe) {} + + // Get a copy of this LinearClassifierFst. See Fst<>::Copy() for further doc. + LinearClassifierFst *Copy(bool safe = false) const override { + return new LinearClassifierFst(*this, safe); + } + + inline void InitStateIterator(StateIteratorData *data) const override; + + void InitArcIterator(StateId s, ArcIteratorData *data) const override { + GetMutableImpl()->InitArcIterator(s, data); + } + + MatcherBase *InitMatcher(MatchType match_type) const override { + return new LinearFstMatcherTpl>(this, match_type); + } + + static LinearClassifierFst *Read(const string &filename) { + if (!filename.empty()) { + std::ifstream strm(filename, + std::ios_base::in | std::ios_base::binary); + if (!strm) { + LOG(ERROR) << "LinearClassifierFst::Read: Can't open file: " + << filename; + return nullptr; + } + return Read(strm, FstReadOptions(filename)); + } else { + return Read(std::cin, FstReadOptions("standard input")); + } + } + + static LinearClassifierFst *Read(std::istream &in, + const FstReadOptions &opts) { + auto *impl = Impl::Read(in, opts); + return impl ? new LinearClassifierFst(std::shared_ptr(impl)) + : nullptr; + } + + bool Write(const string &filename) const override { + if (!filename.empty()) { + std::ofstream strm(filename, + std::ios_base::out | std::ios_base::binary); + if (!strm) { + LOG(ERROR) << "ProdLmFst::Write: Can't open file: " << filename; + return false; + } + return Write(strm, FstWriteOptions(filename)); + } else { + return Write(std::cout, FstWriteOptions("standard output")); + } + } + + bool Write(std::ostream &strm, const FstWriteOptions &opts) const override { + return GetImpl()->Write(strm, opts); + } + + private: + using ImplToFst::GetImpl; + using ImplToFst::GetMutableImpl; + + explicit LinearClassifierFst(std::shared_ptr impl) + : ImplToFst(impl) {} + + void operator=(const LinearClassifierFst &fst) = delete; +}; + +// Specialization for LinearClassifierFst. +template +class StateIterator> + : public CacheStateIterator> { + public: + explicit StateIterator(const LinearClassifierFst &fst) + : CacheStateIterator>(fst, + fst.GetMutableImpl()) {} +}; + +// Specialization for LinearClassifierFst. +template +class ArcIterator> + : public CacheArcIterator> { + public: + using StateId = typename Arc::StateId; + + ArcIterator(const LinearClassifierFst &fst, StateId s) + : CacheArcIterator>(fst.GetMutableImpl(), s) { + if (!fst.GetImpl()->HasArcs(s)) fst.GetMutableImpl()->Expand(s); + } +}; + +template +inline void LinearClassifierFst::InitStateIterator( + StateIteratorData *data) const { + data->base = new StateIterator>(*this); +} + +// Specialized Matcher for LinearFsts. This matcher only supports +// matching from the input side. This is intentional because comparing +// the scores of different input sequences with the same output +// sequence is meaningless in a discriminative model. +template +class LinearFstMatcherTpl : public MatcherBase { + public: + typedef typename F::Arc Arc; + typedef typename Arc::Label Label; + typedef typename Arc::Weight Weight; + typedef typename Arc::StateId StateId; + typedef F FST; + + // This makes a copy of the FST. + LinearFstMatcherTpl(const FST &fst, MatchType match_type) + : owned_fst_(fst.Copy()), + fst_(*owned_fst_), + match_type_(match_type), + s_(kNoStateId), + current_loop_(false), + loop_(kNoLabel, 0, Weight::One(), kNoStateId), + cur_arc_(0), + error_(false) { + switch (match_type_) { + case MATCH_INPUT: + case MATCH_OUTPUT: + case MATCH_NONE: + break; + default: + FSTERROR() << "LinearFstMatcherTpl: Bad match type"; + match_type_ = MATCH_NONE; + error_ = true; + } + } + + // This doesn't copy the FST. + LinearFstMatcherTpl(const FST *fst, MatchType match_type) + : fst_(*fst), + match_type_(match_type), + s_(kNoStateId), + current_loop_(false), + loop_(kNoLabel, 0, Weight::One(), kNoStateId), + cur_arc_(0), + error_(false) { + switch (match_type_) { + case MATCH_INPUT: + case MATCH_OUTPUT: + case MATCH_NONE: + break; + default: + FSTERROR() << "LinearFstMatcherTpl: Bad match type"; + match_type_ = MATCH_NONE; + error_ = true; + } + } + + // This makes a copy of the FST. + LinearFstMatcherTpl(const LinearFstMatcherTpl &matcher, bool safe = false) + : owned_fst_(matcher.fst_.Copy(safe)), + fst_(*owned_fst_), + match_type_(matcher.match_type_), + s_(kNoStateId), + current_loop_(false), + loop_(matcher.loop_), + cur_arc_(0), + error_(matcher.error_) {} + + LinearFstMatcherTpl *Copy(bool safe = false) const override { + return new LinearFstMatcherTpl(*this, safe); + } + + MatchType Type(bool /*test*/) const override { + // `MATCH_INPUT` is the only valid type + return match_type_ == MATCH_INPUT ? match_type_ : MATCH_NONE; + } + + void SetState(StateId s) final { + if (s_ == s) return; + s_ = s; + // `MATCH_INPUT` is the only valid type + if (match_type_ != MATCH_INPUT) { + FSTERROR() << "LinearFstMatcherTpl: Bad match type"; + error_ = true; + } + loop_.nextstate = s; + } + + bool Find(Label label) final { + if (error_) { + current_loop_ = false; + return false; + } + current_loop_ = label == 0; + if (label == kNoLabel) label = 0; + arcs_.clear(); + cur_arc_ = 0; + fst_.GetMutableImpl()->MatchInput(s_, label, &arcs_); + return current_loop_ || !arcs_.empty(); + } + + bool Done() const final { + return !(current_loop_ || cur_arc_ < arcs_.size()); + } + + const Arc &Value() const final { + return current_loop_ ? loop_ : arcs_[cur_arc_]; + } + + void Next() final { + if (current_loop_) + current_loop_ = false; + else + ++cur_arc_; + } + + ssize_t Priority(StateId s) final { return kRequirePriority; } + + const FST &GetFst() const override { return fst_; } + + uint64 Properties(uint64 props) const override { + if (error_) props |= kError; + return props; + } + + uint32 Flags() const override { return kRequireMatch; } + + private: + std::unique_ptr owned_fst_; + const FST &fst_; + MatchType match_type_; // Type of match to perform. + StateId s_; // Current state. + bool current_loop_; // Current arc is the implicit loop. + Arc loop_; // For non-consuming symbols. + // All out-going arcs matching the label in last Find() call. + std::vector arcs_; + size_t cur_arc_; // Index to the arc that `Value()` should return. + bool error_; // Error encountered. +}; + +} // namespace fst + +#endif // FST_EXTENSIONS_LINEAR_LINEAR_FST_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/linear/linearscript.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/linear/linearscript.h new file mode 100644 index 0000000000..54106d20f8 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/linear/linearscript.h @@ -0,0 +1,391 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_EXTENSIONS_LINEAR_LINEARSCRIPT_H_ +#define FST_EXTENSIONS_LINEAR_LINEARSCRIPT_H_ + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +DECLARE_string(delimiter); +DECLARE_string(empty_symbol); +DECLARE_string(start_symbol); +DECLARE_string(end_symbol); +DECLARE_bool(classifier); + +namespace fst { +namespace script { +typedef std::tuple + LinearCompileArgs; + +bool ValidateDelimiter(); +bool ValidateEmptySymbol(); + +// Returns the proper label given the symbol. For symbols other than +// `FLAGS_start_symbol` or `FLAGS_end_symbol`, looks up the symbol +// table to decide the label. Depending on whether +// `FLAGS_start_symbol` and `FLAGS_end_symbol` are identical, it +// either returns `kNoLabel` for later processing or decides the label +// right away. +template +inline typename Arc::Label LookUp(const string &str, SymbolTable *syms) { + if (str == FLAGS_start_symbol) + return str == FLAGS_end_symbol ? kNoLabel + : LinearFstData::kStartOfSentence; + else if (str == FLAGS_end_symbol) + return LinearFstData::kEndOfSentence; + else + return syms->AddSymbol(str); +} + +// Splits `str` with `delim` as the delimiter and stores the labels in +// `output`. +template +void SplitAndPush(const string &str, const char delim, SymbolTable *syms, + std::vector *output) { + if (str == FLAGS_empty_symbol) return; + std::istringstream strm(str); + string buf; + while (std::getline(strm, buf, delim)) + output->push_back(LookUp(buf, syms)); +} + +// Like `std::replace_copy` but returns the number of modifications +template +size_t ReplaceCopy(InputIterator first, InputIterator last, + OutputIterator result, const T &old_value, + const T &new_value) { + size_t changes = 0; + while (first != last) { + if (*first == old_value) { + *result = new_value; + ++changes; + } else { + *result = *first; + } + ++first; + ++result; + } + return changes; +} + +template +bool GetVocabRecord(const string &vocab, std::istream &strm, // NOLINT + SymbolTable *isyms, SymbolTable *fsyms, SymbolTable *osyms, + typename Arc::Label *word, + std::vector *feature_labels, + std::vector *possible_labels, + size_t *num_line); + +template +bool GetModelRecord(const string &model, std::istream &strm, // NOLINT + SymbolTable *fsyms, SymbolTable *osyms, + std::vector *input_labels, + std::vector *output_labels, + typename Arc::Weight *weight, size_t *num_line); + +// Reads in vocabulary file. Each line is in the following format +// +// word features [ possible output ] +// +// where features and possible output are `FLAGS_delimiter`-delimited lists of +// tokens +template +void AddVocab(const string &vocab, SymbolTable *isyms, SymbolTable *fsyms, + SymbolTable *osyms, LinearFstDataBuilder *builder) { + std::ifstream in(vocab); + if (!in) LOG(FATAL) << "Can't open file: " << vocab; + size_t num_line = 0, num_added = 0; + std::vector fields; + std::vector feature_labels, possible_labels; + typename Arc::Label word; + while (GetVocabRecord(vocab, in, isyms, fsyms, osyms, &word, + &feature_labels, &possible_labels, &num_line)) { + if (word == kNoLabel) { + LOG(WARNING) << "Ignored: boundary word: " << fields[0]; + continue; + } + if (possible_labels.empty()) + num_added += builder->AddWord(word, feature_labels); + else + num_added += builder->AddWord(word, feature_labels, possible_labels); + } + VLOG(1) << "Read " << num_added << " words in " << num_line << " lines from " + << vocab; +} + +template +void AddVocab(const string &vocab, SymbolTable *isyms, SymbolTable *fsyms, + SymbolTable *osyms, + LinearClassifierFstDataBuilder *builder) { + std::ifstream in(vocab); + if (!in) LOG(FATAL) << "Can't open file: " << vocab; + size_t num_line = 0, num_added = 0; + std::vector fields; + std::vector feature_labels, possible_labels; + typename Arc::Label word; + while (GetVocabRecord(vocab, in, isyms, fsyms, osyms, &word, + &feature_labels, &possible_labels, &num_line)) { + if (!possible_labels.empty()) + LOG(FATAL) + << "Classifier vocabulary should not have possible output constraint"; + if (word == kNoLabel) { + LOG(WARNING) << "Ignored: boundary word: " << fields[0]; + continue; + } + num_added += builder->AddWord(word, feature_labels); + } + VLOG(1) << "Read " << num_added << " words in " << num_line << " lines from " + << vocab; +} + +// Reads in model file. The first line is an integer designating the +// size of future window in the input sequences. After this, each line +// is in the following format +// +// input sequence output sequence weight +// +// input sequence is a `FLAGS_delimiter`-delimited sequence of feature +// labels (see `AddVocab()`) . output sequence is a +// `FLAGS_delimiter`-delimited sequence of output labels where the +// last label is the output of the feature position before the history +// boundary. +template +void AddModel(const string &model, SymbolTable *fsyms, SymbolTable *osyms, + LinearFstDataBuilder *builder) { + std::ifstream in(model); + if (!in) LOG(FATAL) << "Can't open file: " << model; + string line; + std::getline(in, line); + if (!in) LOG(FATAL) << "Empty file: " << model; + size_t future_size; + { + std::istringstream strm(line); + strm >> future_size; + if (!strm) LOG(FATAL) << "Can't read future size: " << model; + } + size_t num_line = 1, num_added = 0; + const int group = builder->AddGroup(future_size); + VLOG(1) << "Group " << group << ": from " << model << "; future size is " + << future_size << "."; + // Add the rest of lines as a single feature group + std::vector fields; + std::vector input_labels, output_labels; + typename Arc::Weight weight; + while (GetModelRecord(model, in, fsyms, osyms, &input_labels, + &output_labels, &weight, &num_line)) { + if (output_labels.empty()) + LOG(FATAL) << "Empty output sequence in source " << model << ", line " + << num_line; + + const typename Arc::Label marks[] = {LinearFstData::kStartOfSentence, + LinearFstData::kEndOfSentence}; + + std::vector copy_input(input_labels.size()), + copy_output(output_labels.size()); + for (int i = 0; i < 2; ++i) { + for (int j = 0; j < 2; ++j) { + size_t num_input_changes = + ReplaceCopy(input_labels.begin(), input_labels.end(), + copy_input.begin(), kNoLabel, marks[i]); + size_t num_output_changes = + ReplaceCopy(output_labels.begin(), output_labels.end(), + copy_output.begin(), kNoLabel, marks[j]); + if ((num_input_changes > 0 || i == 0) && + (num_output_changes > 0 || j == 0)) + num_added += + builder->AddWeight(group, copy_input, copy_output, weight); + } + } + } + VLOG(1) << "Group " << group << ": read " << num_added << " weight(s) in " + << num_line << " lines."; +} + +template +void AddModel(const string &model, SymbolTable *fsyms, SymbolTable *osyms, + LinearClassifierFstDataBuilder *builder) { + std::ifstream in(model); + if (!in) LOG(FATAL) << "Can't open file: " << model; + string line; + std::getline(in, line); + if (!in) LOG(FATAL) << "Empty file: " << model; + size_t future_size; + { + std::istringstream strm(line); + strm >> future_size; + if (!strm) LOG(FATAL) << "Can't read future size: " << model; + } + if (future_size != 0) + LOG(FATAL) << "Classifier model must have future size = 0; got " + << future_size << " from " << model; + size_t num_line = 1, num_added = 0; + const int group = builder->AddGroup(); + VLOG(1) << "Group " << group << ": from " << model << "; future size is " + << future_size << "."; + // Add the rest of lines as a single feature group + std::vector fields; + std::vector input_labels, output_labels; + typename Arc::Weight weight; + while (GetModelRecord(model, in, fsyms, osyms, &input_labels, + &output_labels, &weight, &num_line)) { + if (output_labels.size() != 1) + LOG(FATAL) << "Output not a single label in source " << model << ", line " + << num_line; + + const typename Arc::Label marks[] = {LinearFstData::kStartOfSentence, + LinearFstData::kEndOfSentence}; + + typename Arc::Label pred = output_labels[0]; + + std::vector copy_input(input_labels.size()); + for (int i = 0; i < 2; ++i) { + size_t num_input_changes = + ReplaceCopy(input_labels.begin(), input_labels.end(), + copy_input.begin(), kNoLabel, marks[i]); + if (num_input_changes > 0 || i == 0) + num_added += builder->AddWeight(group, copy_input, pred, weight); + } + } + VLOG(1) << "Group " << group << ": read " << num_added << " weight(s) in " + << num_line << " lines."; +} + +void SplitByWhitespace(const string &str, std::vector *out); +int ScanNumClasses(char **models, int models_length); + +template +void LinearCompileTpl(LinearCompileArgs *args) { + const string &epsilon_symbol = std::get<0>(*args); + const string &unknown_symbol = std::get<1>(*args); + const string &vocab = std::get<2>(*args); + char **models = std::get<3>(*args); + const int models_length = std::get<4>(*args); + const string &out = std::get<5>(*args); + const string &save_isymbols = std::get<6>(*args); + const string &save_fsymbols = std::get<7>(*args); + const string &save_osymbols = std::get<8>(*args); + + SymbolTable isyms, // input (e.g. word tokens) + osyms, // output (e.g. tags) + fsyms; // feature (e.g. word identity, suffix, etc.) + isyms.AddSymbol(epsilon_symbol); + osyms.AddSymbol(epsilon_symbol); + fsyms.AddSymbol(epsilon_symbol); + isyms.AddSymbol(unknown_symbol); + + VLOG(1) << "start-of-sentence label is " + << LinearFstData::kStartOfSentence; + VLOG(1) << "end-of-sentence label is " << LinearFstData::kEndOfSentence; + + if (FLAGS_classifier) { + int num_classes = ScanNumClasses(models, models_length); + LinearClassifierFstDataBuilder builder(num_classes, &isyms, &fsyms, + &osyms); + + AddVocab(vocab, &isyms, &fsyms, &osyms, &builder); + for (int i = 0; i < models_length; ++i) + AddModel(models[i], &fsyms, &osyms, &builder); + + LinearClassifierFst fst(builder.Dump(), num_classes, &isyms, &osyms); + fst.Write(out); + } else { + LinearFstDataBuilder builder(&isyms, &fsyms, &osyms); + + AddVocab(vocab, &isyms, &fsyms, &osyms, &builder); + for (int i = 0; i < models_length; ++i) + AddModel(models[i], &fsyms, &osyms, &builder); + + LinearTaggerFst fst(builder.Dump(), &isyms, &osyms); + fst.Write(out); + } + + if (!save_isymbols.empty()) isyms.WriteText(save_isymbols); + if (!save_fsymbols.empty()) fsyms.WriteText(save_fsymbols); + if (!save_osymbols.empty()) osyms.WriteText(save_osymbols); +} + +void LinearCompile(const string &arc_type, const string &epsilon_symbol, + const string &unknown_symbol, const string &vocab, + char **models, int models_len, const string &out, + const string &save_isymbols, const string &save_fsymbols, + const string &save_osymbols); + +template +bool GetVocabRecord(const string &vocab, std::istream &strm, // NOLINT + SymbolTable *isyms, SymbolTable *fsyms, SymbolTable *osyms, + typename Arc::Label *word, + std::vector *feature_labels, + std::vector *possible_labels, + size_t *num_line) { + string line; + if (!std::getline(strm, line)) return false; + ++(*num_line); + + std::vector fields; + SplitByWhitespace(line, &fields); + if (fields.size() != 3) + LOG(FATAL) << "Wrong number of fields in source " << vocab << ", line " + << num_line; + + feature_labels->clear(); + possible_labels->clear(); + + *word = LookUp(fields[0], isyms); + + const char delim = FLAGS_delimiter[0]; + SplitAndPush(fields[1], delim, fsyms, feature_labels); + SplitAndPush(fields[2], delim, osyms, possible_labels); + + return true; +} + +template +bool GetModelRecord(const string &model, std::istream &strm, // NOLINT + SymbolTable *fsyms, SymbolTable *osyms, + std::vector *input_labels, + std::vector *output_labels, + typename Arc::Weight *weight, size_t *num_line) { + string line; + if (!std::getline(strm, line)) return false; + ++(*num_line); + + std::vector fields; + SplitByWhitespace(line, &fields); + if (fields.size() != 3) + LOG(FATAL) << "Wrong number of fields in source " << model << ", line " + << num_line; + + input_labels->clear(); + output_labels->clear(); + + const char delim = FLAGS_delimiter[0]; + SplitAndPush(fields[0], delim, fsyms, input_labels); + SplitAndPush(fields[1], delim, osyms, output_labels); + + *weight = StrToWeight(fields[2], model, *num_line); + + GuessStartOrEnd(input_labels, kNoLabel); + GuessStartOrEnd(output_labels, kNoLabel); + + return true; +} +} // namespace script +} // namespace fst + +#define REGISTER_FST_LINEAR_OPERATIONS(Arc) \ + REGISTER_FST_OPERATION(LinearCompileTpl, Arc, LinearCompileArgs); + +#endif // FST_EXTENSIONS_LINEAR_LINEARSCRIPT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/linear/loglinear-apply.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/linear/loglinear-apply.h new file mode 100644 index 0000000000..1b5d2eaf86 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/linear/loglinear-apply.h @@ -0,0 +1,77 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_EXTENSIONS_LINEAR_LOGLINEAR_APPLY_H_ +#define FST_EXTENSIONS_LINEAR_LOGLINEAR_APPLY_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace fst { + +// Applies a FST model as a discriminative model to weighted input +// `ifst`. `A` is an arc type with tropical weight of all the +// input/output FSTs. +// +// In general, consider `ifst` an unnormalized probability +// distribution between its input X and output Y, P(X, Y); and `lfst` +// a group of unnormalized probability distributions of all its output +// Z for every input Y, Q(Z|Y). `normalize` controls whether Q is +// normalized for every Y before chaining with P(X, Y). I.e., for a +// path (X, Y, Z) in `ofst` (where Y is hidden), +// +// - When `normalize` is true, its weight is P(X, Y) Q(Z|Y) / sum_z Q(z|Y); +// - When `normalize` is false, its weight is P(X, Y) Q(Z|Y). +template +void LogLinearApply(const Fst &ifst, const Fst &lfst, MutableFst *ofst, + bool normalize = true) { + LogLinearApply(ifst, lfst, ofst, normalize); +} + +// This version gives finer control over the arc type (`B`) to be used +// in normalization. `B` is an arc type with log weight (e.g. `LogArc` +// or `Log64Arc`). +template +void LogLinearApply(const Fst &ifst, const Fst &lfst, MutableFst *ofst, + bool normalize = true) { + if (normalize) { + VectorFst unnormalized_ofst, rescored_ifsa; + Compose(ifst, lfst, &unnormalized_ofst); + { + VectorFst tropical_ifsa(unnormalized_ofst); + Project(&tropical_ifsa, PROJECT_INPUT); + { + VectorFst minimal_log_ifsa; + { + VectorFst log_ifsa; + ArcMap(tropical_ifsa, &log_ifsa, WeightConvertMapper()); + RmEpsilon(&log_ifsa); + Determinize(log_ifsa, &minimal_log_ifsa); + } + Minimize(&minimal_log_ifsa); + ArcMap(&minimal_log_ifsa, InvertWeightMapper()); + ArcMap(minimal_log_ifsa, &tropical_ifsa, WeightConvertMapper()); + } + ArcSort(&tropical_ifsa, OLabelCompare()); + Compose(tropical_ifsa, ifst, &rescored_ifsa); + } + ArcSort(&rescored_ifsa, OLabelCompare()); + Compose(rescored_ifsa, unnormalized_ofst, ofst); + } else { + Compose(ifst, lfst, ofst); + } +} + +} // namespace fst + +#endif // FST_EXTENSIONS_LINEAR_LOGLINEAR_APPLY_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/linear/trie.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/linear/trie.h new file mode 100644 index 0000000000..b5ddb3ad91 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/linear/trie.h @@ -0,0 +1,444 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_EXTENSIONS_LINEAR_TRIE_H_ +#define FST_EXTENSIONS_LINEAR_TRIE_H_ + +#include +#include +#include + +#include +#include + +namespace fst { + +const int kNoTrieNodeId = -1; + +// Forward declarations of all available trie topologies. +template +class NestedTrieTopology; +template +class FlatTrieTopology; + +// A pair of parent node id and label, part of a trie edge +template +struct ParentLabel { + int parent; + L label; + + ParentLabel() {} + ParentLabel(int p, L l) : parent(p), label(l) {} + + bool operator==(const ParentLabel &that) const { + return parent == that.parent && label == that.label; + } + + std::istream &Read(std::istream &strm) { // NOLINT + ReadType(strm, &parent); + ReadType(strm, &label); + return strm; + } + + std::ostream &Write(std::ostream &strm) const { // NOLINT + WriteType(strm, parent); + WriteType(strm, label); + return strm; + } +}; + +template +struct ParentLabelHash { + size_t operator()(const ParentLabel &pl) const { + return static_cast(pl.parent * 7853 + H()(pl.label)); + } +}; + +// The trie topology in a nested tree of hash maps; allows efficient +// iteration over children of a specific node. +template +class NestedTrieTopology { + public: + typedef L Label; + typedef H Hash; + typedef std::unordered_map NextMap; + + class const_iterator { + public: + typedef std::forward_iterator_tag iterator_category; + typedef std::pair, int> value_type; + typedef std::ptrdiff_t difference_type; + typedef const value_type *pointer; + typedef const value_type &reference; + + friend class NestedTrieTopology; + + const_iterator() : ptr_(nullptr), cur_node_(kNoTrieNodeId), cur_edge_() {} + + reference operator*() { + UpdateStub(); + return stub_; + } + pointer operator->() { + UpdateStub(); + return &stub_; + } + + const_iterator &operator++(); + const_iterator &operator++(int); // NOLINT + + bool operator==(const const_iterator &that) const { + return ptr_ == that.ptr_ && cur_node_ == that.cur_node_ && + cur_edge_ == that.cur_edge_; + } + bool operator!=(const const_iterator &that) const { + return !(*this == that); + } + + private: + const_iterator(const NestedTrieTopology *ptr, int cur_node) + : ptr_(ptr), cur_node_(cur_node) { + SetProperCurEdge(); + } + + void SetProperCurEdge() { + if (cur_node_ < ptr_->NumNodes()) + cur_edge_ = ptr_->nodes_[cur_node_]->begin(); + else + cur_edge_ = ptr_->nodes_[0]->begin(); + } + + void UpdateStub() { + stub_.first = ParentLabel(cur_node_, cur_edge_->first); + stub_.second = cur_edge_->second; + } + + const NestedTrieTopology *ptr_; + int cur_node_; + typename NextMap::const_iterator cur_edge_; + value_type stub_; + }; + + NestedTrieTopology(); + NestedTrieTopology(const NestedTrieTopology &that); + ~NestedTrieTopology(); + void swap(NestedTrieTopology &that); + NestedTrieTopology &operator=(const NestedTrieTopology &that); + bool operator==(const NestedTrieTopology &that) const; + bool operator!=(const NestedTrieTopology &that) const; + + int Root() const { return 0; } + size_t NumNodes() const { return nodes_.size(); } + int Insert(int parent, const L &label); + int Find(int parent, const L &label) const; + const NextMap &ChildrenOf(int parent) const { return *nodes_[parent]; } + + std::istream &Read(std::istream &strm); // NOLINT + std::ostream &Write(std::ostream &strm) const; // NOLINT + + const_iterator begin() const { return const_iterator(this, 0); } + const_iterator end() const { return const_iterator(this, NumNodes()); } + + private: + std::vector + nodes_; // Use pointers to avoid copying the maps when the + // vector grows +}; + +template +NestedTrieTopology::NestedTrieTopology() { + nodes_.push_back(new NextMap); +} + +template +NestedTrieTopology::NestedTrieTopology(const NestedTrieTopology &that) { + nodes_.reserve(that.nodes_.size()); + for (size_t i = 0; i < that.nodes_.size(); ++i) { + NextMap *node = that.nodes_[i]; + nodes_.push_back(new NextMap(*node)); + } +} + +template +NestedTrieTopology::~NestedTrieTopology() { + for (size_t i = 0; i < nodes_.size(); ++i) { + NextMap *node = nodes_[i]; + delete node; + } +} + +// TODO(wuke): std::swap compatibility +template +inline void NestedTrieTopology::swap(NestedTrieTopology &that) { + nodes_.swap(that.nodes_); +} + +template +inline NestedTrieTopology &NestedTrieTopology::operator=( + const NestedTrieTopology &that) { + NestedTrieTopology copy(that); + swap(copy); + return *this; +} + +template +inline bool NestedTrieTopology::operator==( + const NestedTrieTopology &that) const { + if (NumNodes() != that.NumNodes()) return false; + for (int i = 0; i < NumNodes(); ++i) + if (ChildrenOf(i) != that.ChildrenOf(i)) return false; + return true; +} + +template +inline bool NestedTrieTopology::operator!=( + const NestedTrieTopology &that) const { + return !(*this == that); +} + +template +inline int NestedTrieTopology::Insert(int parent, const L &label) { + int ret = Find(parent, label); + if (ret == kNoTrieNodeId) { + ret = NumNodes(); + (*nodes_[parent])[label] = ret; + nodes_.push_back(new NextMap); + } + return ret; +} + +template +inline int NestedTrieTopology::Find(int parent, const L &label) const { + typename NextMap::const_iterator it = nodes_[parent]->find(label); + return it == nodes_[parent]->end() ? kNoTrieNodeId : it->second; +} + +template +inline std::istream &NestedTrieTopology::Read( + std::istream &strm) { // NOLINT + NestedTrieTopology new_trie; + size_t num_nodes; + if (!ReadType(strm, &num_nodes)) return strm; + for (size_t i = 1; i < num_nodes; ++i) new_trie.nodes_.push_back(new NextMap); + for (size_t i = 0; i < num_nodes; ++i) ReadType(strm, new_trie.nodes_[i]); + if (strm) swap(new_trie); + return strm; +} + +template +inline std::ostream &NestedTrieTopology::Write( + std::ostream &strm) const { // NOLINT + WriteType(strm, NumNodes()); + for (size_t i = 0; i < NumNodes(); ++i) WriteType(strm, *nodes_[i]); + return strm; +} + +template +inline typename NestedTrieTopology::const_iterator + &NestedTrieTopology::const_iterator::operator++() { + ++cur_edge_; + if (cur_edge_ == ptr_->nodes_[cur_node_]->end()) { + ++cur_node_; + while (cur_node_ < ptr_->NumNodes() && ptr_->nodes_[cur_node_]->empty()) + ++cur_node_; + SetProperCurEdge(); + } + return *this; +} + +template +inline typename NestedTrieTopology::const_iterator + &NestedTrieTopology::const_iterator::operator++(int) { // NOLINT + const_iterator save(*this); + ++(*this); + return save; +} + +// The trie topology in a single hash map; only allows iteration over +// all the edges in arbitrary order. +template +class FlatTrieTopology { + private: + typedef std::unordered_map, int, ParentLabelHash> + NextMap; + + public: + // Iterator over edges as std::pair, int> + typedef typename NextMap::const_iterator const_iterator; + typedef L Label; + typedef H Hash; + + FlatTrieTopology() {} + FlatTrieTopology(const FlatTrieTopology &that) : next_(that.next_) {} + template + explicit FlatTrieTopology(const T &that); + + // TODO(wuke): std::swap compatibility + void swap(FlatTrieTopology &that) { next_.swap(that.next_); } + + bool operator==(const FlatTrieTopology &that) const { + return next_ == that.next_; + } + bool operator!=(const FlatTrieTopology &that) const { + return !(*this == that); + } + + int Root() const { return 0; } + size_t NumNodes() const { return next_.size() + 1; } + int Insert(int parent, const L &label); + int Find(int parent, const L &label) const; + + std::istream &Read(std::istream &strm) { // NOLINT + return ReadType(strm, &next_); + } + std::ostream &Write(std::ostream &strm) const { // NOLINT + return WriteType(strm, next_); + } + + const_iterator begin() const { return next_.begin(); } + const_iterator end() const { return next_.end(); } + + private: + NextMap next_; +}; + +template +template +FlatTrieTopology::FlatTrieTopology(const T &that) + : next_(that.begin(), that.end()) {} + +template +inline int FlatTrieTopology::Insert(int parent, const L &label) { + int ret = Find(parent, label); + if (ret == kNoTrieNodeId) { + ret = NumNodes(); + next_[ParentLabel(parent, label)] = ret; + } + return ret; +} + +template +inline int FlatTrieTopology::Find(int parent, const L &label) const { + typename NextMap::const_iterator it = + next_.find(ParentLabel(parent, label)); + return it == next_.end() ? kNoTrieNodeId : it->second; +} + +// A collection of implementations of the trie data structure. The key +// is a sequence of type `L` which must be hashable. The value is of +// `V` which must be default constructible and copyable. In addition, +// a value object is stored for each node in the trie therefore +// copying `V` should be cheap. +// +// One can access the store values with an integer node id, using the +// [] operator. A valid node id can be obtained by the following ways: +// +// 1. Using the `Root()` method to get the node id of the root. +// +// 2. Iterating through 0 to `NumNodes() - 1`. The node ids are dense +// so every integer in this range is a valid node id. +// +// 3. Using the node id returned from a successful `Insert()` or +// `Find()` call. +// +// 4. Iterating over the trie edges with an `EdgeIterator` and using +// the node ids returned from its `Parent()` and `Child()` methods. +// +// Below is an example of inserting keys into the trie: +// +// const string words[] = {"hello", "health", "jello"}; +// Trie dict; +// for (auto word : words) { +// int cur = dict.Root(); +// for (char c : word) { +// cur = dict.Insert(cur, c); +// } +// dict[cur] = true; +// } +// +// And the following is an example of looking up the longest prefix of +// a string using the trie constructed above: +// +// string query = "healed"; +// size_t prefix_length = 0; +// int cur = dict.Find(dict.Root(), query[prefix_length]); +// while (prefix_length < query.size() && +// cur != Trie::kNoNodeId) { +// ++prefix_length; +// cur = dict.Find(cur, query[prefix_length]); +// } +template +class MutableTrie { + public: + template + friend class MutableTrie; + + typedef L Label; + typedef V Value; + typedef T Topology; + + // Constructs a trie with only the root node. + MutableTrie() {} + + // Conversion from another trie of a possiblly different + // topology. The underlying topology must supported conversion. + template + explicit MutableTrie(const MutableTrie &that) + : topology_(that.topology_), values_(that.values_) {} + + // TODO(wuke): std::swap compatibility + void swap(MutableTrie &that) { + topology_.swap(that.topology_); + values_.swap(that.values_); + } + + int Root() const { return topology_.Root(); } + size_t NumNodes() const { return topology_.NumNodes(); } + + // Inserts an edge with given `label` at node `parent`. Returns the + // child node id. If the node already exists, returns the node id + // right away. + int Insert(int parent, const L &label) { + int ret = topology_.Insert(parent, label); + values_.resize(NumNodes()); + return ret; + } + + // Finds the node id of the node from `parent` via `label`. Returns + // `kNoTrieNodeId` when such a node does not exist. + int Find(int parent, const L &label) const { + return topology_.Find(parent, label); + } + + const T &TrieTopology() const { return topology_; } + + // Accesses the value stored for the given node. + V &operator[](int node_id) { return values_[node_id]; } + const V &operator[](int node_id) const { return values_[node_id]; } + + // Comparison by content + bool operator==(const MutableTrie &that) const { + return topology_ == that.topology_ && values_ == that.values_; + } + + bool operator!=(const MutableTrie &that) const { return !(*this == that); } + + std::istream &Read(std::istream &strm) { // NOLINT + ReadType(strm, &topology_); + ReadType(strm, &values_); + return strm; + } + std::ostream &Write(std::ostream &strm) const { // NOLINT + WriteType(strm, topology_); + WriteType(strm, values_); + return strm; + } + + private: + T topology_; + std::vector values_; +}; + +} // namespace fst + +#endif // FST_EXTENSIONS_LINEAR_TRIE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/mpdt/compose.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/mpdt/compose.h new file mode 100644 index 0000000000..47714e3765 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/mpdt/compose.h @@ -0,0 +1,267 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Compose an MPDT and an FST. + +#ifndef FST_EXTENSIONS_MPDT_COMPOSE_H_ +#define FST_EXTENSIONS_MPDT_COMPOSE_H_ + +#include + +#include +#include +#include + +namespace fst { + +template +class MPdtParenFilter { + public: + using FST1 = typename Filter::FST1; + using FST2 = typename Filter::FST2; + using Arc = typename Filter::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using Matcher1 = typename Filter::Matcher1; + using Matcher2 = typename Filter::Matcher2; + + using StackId = StateId; + using ParenStack = internal::MPdtStack; + using FilterState1 = typename Filter::FilterState; + using FilterState2 = IntegerFilterState; + using FilterState = PairFilterState; + + MPdtParenFilter(const FST1 &fst1, const FST2 &fst2, + Matcher1 *matcher1 = nullptr, Matcher2 *matcher2 = nullptr, + const std::vector> *parens = nullptr, + const std::vector(*this, safe); + } + + inline void InitStateIterator(StateIteratorData *data) const override; + + void InitArcIterator(StateId s, ArcIteratorData *data) const override { + GetMutableImpl()->InitArcIterator(s, data); + } + + const ParenStack &GetStack() const { return GetImpl()->GetStack(); } + + const PdtStateTable &GetStateTable() const { + return GetImpl()->GetStateTable(); + } + + private: + using ImplToFst::GetImpl; + using ImplToFst::GetMutableImpl; + + void operator=(const MPdtExpandFst &) = delete; +}; + +// Specialization for MPdtExpandFst. +template +class StateIterator> + : public CacheStateIterator> { + public: + explicit StateIterator(const MPdtExpandFst &fst) + : CacheStateIterator>(fst, fst.GetMutableImpl()) {} +}; + +// Specialization for MPdtExpandFst. +template +class ArcIterator> + : public CacheArcIterator> { + public: + using StateId = typename Arc::StateId; + + ArcIterator(const MPdtExpandFst &fst, StateId s) + : CacheArcIterator>(fst.GetMutableImpl(), s) { + if (!fst.GetImpl()->HasArcs(s)) fst.GetMutableImpl()->ExpandState(s); + } +}; + +template +inline void MPdtExpandFst::InitStateIterator( + StateIteratorData *data) const { + data->base = new StateIterator>(*this); +} + +struct MPdtExpandOptions { + bool connect; + bool keep_parentheses; + + explicit MPdtExpandOptions(bool connect = true, bool keep_parentheses = false) + : connect(connect), keep_parentheses(keep_parentheses) {} +}; + +// Expands a multi-pushdown transducer (MPDT) encoded as an FST into an FST. +// This version writes the expanded PDT to a mutable FST. In the MPDT, some +// transitions are labeled with open or close parentheses. To be interpreted as +// an MPDT, the parens for each stack must balance on a path. The open-close +// parenthesis label pair sets are passed using the parens argument, and the +// assignment of those pairs to stacks is passed using the assignments argument. +// The expansion enforces the parenthesis constraints. The MPDT must be +// expandable as an FST. +template +void Expand(const Fst &ifst, + const std::vector< + std::pair> &parens, + const std::vector &assignments, + MutableFst *ofst, const MPdtExpandOptions &opts) { + MPdtExpandFstOptions eopts; + eopts.gc_limit = 0; + eopts.keep_parentheses = opts.keep_parentheses; + *ofst = MPdtExpandFst(ifst, parens, assignments, eopts); + if (opts.connect) Connect(ofst); +} + +// Expands a multi-pushdown transducer (MPDT) encoded as an FST into an FST. +// This version writes the expanded PDT to a mutable FST. In the MPDT, some +// transitions are labeled with open or close parentheses. To be interpreted as +// an MPDT, the parens for each stack must balance on a path. The open-close +// parenthesis label pair sets are passed using the parens argument, and the +// assignment of those pairs to stacks is passed using the assignments argument. +// The expansion enforces the parenthesis constraints. The MPDT must be +// expandable as an FST. +template +void Expand(const Fst &ifst, + const std::vector> &parens, + const std::vector &assignments, + MutableFst *ofst, bool connect = true, + bool keep_parentheses = false) { + const MPdtExpandOptions opts(connect, keep_parentheses); + Expand(ifst, parens, assignments, ofst, opts); +} + +} // namespace fst + +#endif // FST_EXTENSIONS_MPDT_EXPAND_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/mpdt/info.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/mpdt/info.h new file mode 100644 index 0000000000..512fcfa80c --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/mpdt/info.h @@ -0,0 +1,190 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Prints information about an MPDT. + +#ifndef FST_EXTENSIONS_MPDT_INFO_H_ +#define FST_EXTENSIONS_MPDT_INFO_H_ + +#include +#include + +#include +#include + +namespace fst { + +// Compute various information about MPDTs, helper class for mpdtinfo.cc. +template +class MPdtInfo { + public: + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + MPdtInfo(const Fst &fst, + const std::vector> &parens, + const std::vector { + using FstImpl::SetInputSymbols; + using FstImpl::SetOutputSymbols; + using FstImpl::SetType; + using FstImpl::WriteHeader; + + friend class ArcIterator>; + friend class NGramFstMatcher; + + public: + using FstImpl::InputSymbols; + using FstImpl::SetProperties; + using FstImpl::Properties; + + typedef A Arc; + typedef typename A::Label Label; + typedef typename A::StateId StateId; + typedef typename A::Weight Weight; + + NGramFstImpl() { + SetType("ngram"); + SetInputSymbols(nullptr); + SetOutputSymbols(nullptr); + SetProperties(kStaticProperties); + } + + NGramFstImpl(const Fst &fst, std::vector *order_out); + + explicit NGramFstImpl(const Fst &fst) : NGramFstImpl(fst, nullptr) {} + + NGramFstImpl(const NGramFstImpl &other) { + FSTERROR() << "Copying NGramFst Impls is not supported, use safe = false."; + SetProperties(kError, kError); + } + + ~NGramFstImpl() override { + if (owned_) { + delete[] data_; + } + } + + static NGramFstImpl *Read(std::istream &strm, // NOLINT + const FstReadOptions &opts) { + NGramFstImpl *impl = new NGramFstImpl(); + FstHeader hdr; + if (!impl->ReadHeader(strm, opts, kMinFileVersion, &hdr)) return 0; + uint64 num_states, num_futures, num_final; + const size_t offset = + sizeof(num_states) + sizeof(num_futures) + sizeof(num_final); + // Peek at num_states and num_futures to see how much more needs to be read. + strm.read(reinterpret_cast(&num_states), sizeof(num_states)); + strm.read(reinterpret_cast(&num_futures), sizeof(num_futures)); + strm.read(reinterpret_cast(&num_final), sizeof(num_final)); + size_t size = Storage(num_states, num_futures, num_final); + MappedFile *data_region = MappedFile::Allocate(size); + char *data = reinterpret_cast(data_region->mutable_data()); + // Copy num_states, num_futures and num_final back into data. + memcpy(data, reinterpret_cast(&num_states), sizeof(num_states)); + memcpy(data + sizeof(num_states), reinterpret_cast(&num_futures), + sizeof(num_futures)); + memcpy(data + sizeof(num_states) + sizeof(num_futures), + reinterpret_cast(&num_final), sizeof(num_final)); + strm.read(data + offset, size - offset); + if (strm.fail()) { + delete impl; + return nullptr; + } + impl->Init(data, false, data_region); + return impl; + } + + bool Write(std::ostream &strm, // NOLINT + const FstWriteOptions &opts) const { + FstHeader hdr; + hdr.SetStart(Start()); + hdr.SetNumStates(num_states_); + WriteHeader(strm, opts, kFileVersion, &hdr); + strm.write(data_, StorageSize()); + return !strm.fail(); + } + + StateId Start() const { return start_; } + + Weight Final(StateId state) const { + if (final_index_.Get(state)) { + return final_probs_[final_index_.Rank1(state)]; + } else { + return Weight::Zero(); + } + } + + size_t NumArcs(StateId state, NGramFstInst *inst = nullptr) const { + if (inst == nullptr) { + const std::pair zeros = + (state == 0) ? select_root_ : future_index_.Select0s(state); + return zeros.second - zeros.first - 1; + } + SetInstFuture(state, inst); + return inst->num_futures_ + ((state == 0) ? 0 : 1); + } + + size_t NumInputEpsilons(StateId state) const { + // State 0 has no parent, thus no backoff. + if (state == 0) return 0; + return 1; + } + + size_t NumOutputEpsilons(StateId state) const { + return NumInputEpsilons(state); + } + + StateId NumStates() const { return num_states_; } + + void InitStateIterator(StateIteratorData *data) const { + data->base = 0; + data->nstates = num_states_; + } + + static size_t Storage(uint64 num_states, uint64 num_futures, + uint64 num_final) { + uint64 b64; + Weight weight; + Label label; + size_t offset = + sizeof(num_states) + sizeof(num_futures) + sizeof(num_final); + offset += + sizeof(b64) * (BitmapIndex::StorageSize(num_states * 2 + 1) + + BitmapIndex::StorageSize(num_futures + num_states + 1) + + BitmapIndex::StorageSize(num_states)); + offset += (num_states + 1) * sizeof(label) + num_futures * sizeof(label); + // Pad for alignemnt, see + // http://en.wikipedia.org/wiki/Data_structure_alignment#Computing_padding + offset = (offset + sizeof(weight) - 1) & ~(sizeof(weight) - 1); + offset += (num_states + 1) * sizeof(weight) + num_final * sizeof(weight) + + (num_futures + 1) * sizeof(weight); + return offset; + } + + void SetInstFuture(StateId state, NGramFstInst *inst) const { + if (inst->state_ != state) { + inst->state_ = state; + const std::pair zeros = future_index_.Select0s(state); + inst->num_futures_ = zeros.second - zeros.first - 1; + inst->offset_ = future_index_.Rank1(zeros.first + 1); + } + } + + void SetInstNode(NGramFstInst *inst) const { + if (inst->node_state_ != inst->state_) { + inst->node_state_ = inst->state_; + inst->node_ = context_index_.Select1(inst->state_); + } + } + + void SetInstContext(NGramFstInst *inst) const { + SetInstNode(inst); + if (inst->context_state_ != inst->state_) { + inst->context_state_ = inst->state_; + inst->context_.clear(); + size_t node = inst->node_; + while (node != 0) { + inst->context_.push_back(context_words_[context_index_.Rank1(node)]); + node = context_index_.Select1(context_index_.Rank0(node) - 1); + } + } + } + + // Access to the underlying representation + const char *GetData(size_t *data_size) const { + *data_size = StorageSize(); + return data_; + } + + void Init(const char *data, bool owned, MappedFile *file = nullptr); + + const std::vector *inst) const { + SetInstFuture(s, inst); + SetInstContext(inst); + return inst->context_; + } + + size_t StorageSize() const { + return Storage(num_states_, num_futures_, num_final_); + } + + void GetStates(const std::vector::GetStates( + const std::vector; + + public: + typedef A Arc; + typedef typename A::StateId StateId; + typedef typename A::Label Label; + typedef typename A::Weight Weight; + typedef internal::NGramFstImpl Impl; + + explicit NGramFst(const Fst &dst) + : ImplToExpandedFst(std::make_shared(dst, nullptr)) {} + + NGramFst(const Fst &fst, std::vector *order_out) + : ImplToExpandedFst(std::make_shared(fst, order_out)) {} + + // Because the NGramFstImpl is a const stateless data structure, there + // is never a need to do anything beside copy the reference. + NGramFst(const NGramFst &fst, bool safe = false) + : ImplToExpandedFst(fst, false) {} + + NGramFst() : ImplToExpandedFst(std::make_shared()) {} + + // Non-standard constructor to initialize NGramFst directly from data. + NGramFst(const char *data, bool owned) + : ImplToExpandedFst(std::make_shared()) { + GetMutableImpl()->Init(data, owned, nullptr); + } + + // Get method that gets the data associated with Init(). + const char *GetData(size_t *data_size) const { + return GetImpl()->GetData(data_size); + } + + const std::vector *Copy(bool safe = false) const override { + return new NGramFst(*this, safe); + } + + static NGramFst *Read(std::istream &strm, const FstReadOptions &opts) { + Impl *impl = Impl::Read(strm, opts); + return impl ? new NGramFst(std::shared_ptr(impl)) : nullptr; + } + + static NGramFst *Read(const string &filename) { + if (!filename.empty()) { + std::ifstream strm(filename, + std::ios_base::in | std::ios_base::binary); + if (!strm.good()) { + LOG(ERROR) << "NGramFst::Read: Can't open file: " << filename; + return nullptr; + } + return Read(strm, FstReadOptions(filename)); + } else { + return Read(std::cin, FstReadOptions("standard input")); + } + } + + bool Write(std::ostream &strm, const FstWriteOptions &opts) const override { + return GetImpl()->Write(strm, opts); + } + + bool Write(const string &filename) const override { + return Fst::WriteFile(filename); + } + + inline void InitStateIterator(StateIteratorData *data) const override { + GetImpl()->InitStateIterator(data); + } + + inline void InitArcIterator(StateId s, + ArcIteratorData *data) const override; + + MatcherBase *InitMatcher(MatchType match_type) const override { + return new NGramFstMatcher(this, match_type); + } + + size_t StorageSize() const { return GetImpl()->StorageSize(); } + + static bool HasRequiredProps(const Fst &fst) { + int64 props = + kAcceptor | kIDeterministic | kILabelSorted | kIEpsilons | kAccessible; + return fst.Properties(props, true) == props; + } + + static bool HasRequiredStructure(const Fst &fst) { + if (!HasRequiredProps(fst)) { + return false; + } + typename A::StateId unigram = fst.Start(); + while (true) { // Follows epsilon arc chain to find unigram state. + if (unigram == fst::kNoStateId) return false; // No unigram state. + typename fst::ArcIterator> aiter(fst, unigram); + if (aiter.Done() || aiter.Value().ilabel != 0) break; + unigram = aiter.Value().nextstate; + aiter.Next(); + } + // Other requirement: all states other than unigram an epsilon arc. + for (fst::StateIterator> siter(fst); !siter.Done(); + siter.Next()) { + const typename A::StateId &state = siter.Value(); + fst::ArcIterator> aiter(fst, state); + if (state != unigram) { + if (aiter.Done()) return false; + if (aiter.Value().ilabel != 0) return false; + aiter.Next(); + if (!aiter.Done() && aiter.Value().ilabel == 0) return false; + } + } + return true; + } + + private: + using ImplToExpandedFst>::GetImpl; + using ImplToExpandedFst>::GetMutableImpl; + + explicit NGramFst(std::shared_ptr impl) + : ImplToExpandedFst(impl) {} + + mutable NGramFstInst inst_; +}; + +template +inline void NGramFst::InitArcIterator(StateId s, + ArcIteratorData *data) const { + GetImpl()->SetInstFuture(s, &inst_); + GetImpl()->SetInstNode(&inst_); + data->base = new ArcIterator>(*this, s); +} + +namespace internal { + +template +NGramFstImpl::NGramFstImpl(const Fst &fst, + std::vector *order_out) { + typedef A Arc; + typedef typename Arc::Label Label; + typedef typename Arc::Weight Weight; + typedef typename Arc::StateId StateId; + SetType("ngram"); + SetInputSymbols(fst.InputSymbols()); + SetOutputSymbols(fst.OutputSymbols()); + SetProperties(kStaticProperties); + + // Check basic requirements for an OpenGrm language model Fst. + if (!NGramFst::HasRequiredProps(fst)) { + FSTERROR() << "NGramFst only accepts OpenGrm language models as input"; + SetProperties(kError, kError); + return; + } + + int64 num_states = CountStates(fst); + Label *context = new Label[num_states]; + + // Find the unigram state by starting from the start state, following + // epsilons. + StateId unigram = fst.Start(); + while (1) { + if (unigram == kNoStateId) { + FSTERROR() << "Could not identify unigram state"; + SetProperties(kError, kError); + return; + } + ArcIterator> aiter(fst, unigram); + if (aiter.Done()) { + LOG(WARNING) << "Unigram state " << unigram << " has no arcs."; + break; + } + if (aiter.Value().ilabel != 0) break; + unigram = aiter.Value().nextstate; + } + + // Each state's context is determined by the subtree it is under from the + // unigram state. + std::queue> label_queue; + std::vector visited(num_states); + // Force an epsilon link to the start state. + label_queue.push(std::make_pair(fst.Start(), 0)); + for (ArcIterator> aiter(fst, unigram); !aiter.Done(); aiter.Next()) { + label_queue.push( + std::make_pair(aiter.Value().nextstate, aiter.Value().ilabel)); + } + // investigate states in breadth first fashion to assign context words. + while (!label_queue.empty()) { + std::pair &now = label_queue.front(); + if (!visited[now.first]) { + context[now.first] = now.second; + visited[now.first] = true; + for (ArcIterator> aiter(fst, now.first); !aiter.Done(); + aiter.Next()) { + const Arc &arc = aiter.Value(); + if (arc.ilabel != 0) { + label_queue.push(std::make_pair(arc.nextstate, now.second)); + } + } + } + label_queue.pop(); + } + visited.clear(); + + // The arc from the start state should be assigned an epsilon to put it + // in front of the all other labels (which makes Start state 1 after + // unigram which is state 0). + context[fst.Start()] = 0; + + // Build the tree of contexts fst by reversing the epsilon arcs from fst. + VectorFst context_fst; + uint64 num_final = 0; + for (int i = 0; i < num_states; ++i) { + if (fst.Final(i) != Weight::Zero()) { + ++num_final; + } + context_fst.SetFinal(context_fst.AddState(), fst.Final(i)); + } + context_fst.SetStart(unigram); + context_fst.SetInputSymbols(fst.InputSymbols()); + context_fst.SetOutputSymbols(fst.OutputSymbols()); + int64 num_context_arcs = 0; + int64 num_futures = 0; + for (StateIterator> siter(fst); !siter.Done(); siter.Next()) { + const StateId &state = siter.Value(); + num_futures += fst.NumArcs(state) - fst.NumInputEpsilons(state); + ArcIterator> aiter(fst, state); + if (!aiter.Done()) { + const Arc &arc = aiter.Value(); + // this arc goes from state to arc.nextstate, so create an arc from + // arc.nextstate to state to reverse it. + if (arc.ilabel == 0) { + context_fst.AddArc(arc.nextstate, Arc(context[state], context[state], + arc.weight, state)); + num_context_arcs++; + } + } + } + if (num_context_arcs != context_fst.NumStates() - 1) { + FSTERROR() << "Number of contexts arcs != number of states - 1"; + SetProperties(kError, kError); + return; + } + if (context_fst.NumStates() != num_states) { + FSTERROR() << "Number of contexts != number of states"; + SetProperties(kError, kError); + return; + } + int64 context_props = + context_fst.Properties(kIDeterministic | kILabelSorted, true); + if (!(context_props & kIDeterministic)) { + FSTERROR() << "Input Fst is not structured properly"; + SetProperties(kError, kError); + return; + } + if (!(context_props & kILabelSorted)) { + ArcSort(&context_fst, ILabelCompare()); + } + + delete[] context; + + uint64 b64; + Weight weight; + Label label = kNoLabel; + const size_t storage = Storage(num_states, num_futures, num_final); + MappedFile *data_region = MappedFile::Allocate(storage); + char *data = reinterpret_cast(data_region->mutable_data()); + memset(data, 0, storage); + size_t offset = 0; + memcpy(data + offset, reinterpret_cast(&num_states), + sizeof(num_states)); + offset += sizeof(num_states); + memcpy(data + offset, reinterpret_cast(&num_futures), + sizeof(num_futures)); + offset += sizeof(num_futures); + memcpy(data + offset, reinterpret_cast(&num_final), + sizeof(num_final)); + offset += sizeof(num_final); + uint64 *context_bits = reinterpret_cast(data + offset); + offset += BitmapIndex::StorageSize(num_states * 2 + 1) * sizeof(b64); + uint64 *future_bits = reinterpret_cast(data + offset); + offset += + BitmapIndex::StorageSize(num_futures + num_states + 1) * sizeof(b64); + uint64 *final_bits = reinterpret_cast(data + offset); + offset += BitmapIndex::StorageSize(num_states) * sizeof(b64); + Label *context_words = reinterpret_cast::Init(const char *data, bool owned, + MappedFile *data_region) { + if (owned_) { + delete[] data_; + } + data_region_.reset(data_region); + owned_ = owned; + data_ = data; + size_t offset = 0; + num_states_ = *(reinterpret_cast(data_ + offset)); + offset += sizeof(num_states_); + num_futures_ = *(reinterpret_cast(data_ + offset)); + offset += sizeof(num_futures_); + num_final_ = *(reinterpret_cast(data_ + offset)); + offset += sizeof(num_final_); + uint64 bits; + size_t context_bits = num_states_ * 2 + 1; + size_t future_bits = num_futures_ + num_states_ + 1; + context_ = reinterpret_cast(data_ + offset); + offset += BitmapIndex::StorageSize(context_bits) * sizeof(bits); + future_ = reinterpret_cast(data_ + offset); + offset += BitmapIndex::StorageSize(future_bits) * sizeof(bits); + final_ = reinterpret_cast(data_ + offset); + offset += BitmapIndex::StorageSize(num_states_) * sizeof(bits); + context_words_ = reinterpret_cast(data_ + offset); + offset += (num_states_ + 1) * sizeof(*context_words_); + future_words_ = reinterpret_cast(data_ + offset); + offset += num_futures_ * sizeof(*future_words_); + offset = (offset + sizeof(*backoff_) - 1) & ~(sizeof(*backoff_) - 1); + backoff_ = reinterpret_cast(data_ + offset); + offset += (num_states_ + 1) * sizeof(*backoff_); + final_probs_ = reinterpret_cast(data_ + offset); + offset += num_final_ * sizeof(*final_probs_); + future_probs_ = reinterpret_cast(data_ + offset); + + context_index_.BuildIndex(context_, context_bits); + future_index_.BuildIndex(future_, future_bits); + final_index_.BuildIndex(final_, num_states_); + + select_root_ = context_index_.Select0s(0); + if (context_index_.Rank1(0) != 0 || select_root_.first != 1 || + context_index_.Get(2) == false) { + FSTERROR() << "Malformed file"; + SetProperties(kError, kError); + return; + } + root_children_ = context_words_ + context_index_.Rank1(2); + start_ = 1; +} + +template +inline typename A::StateId NGramFstImpl::Transition( + const std::vector { + public: + typedef A Arc; + typedef typename A::Label Label; + typedef typename A::StateId StateId; + typedef typename A::Weight Weight; + + // This makes a copy of the FST. + NGramFstMatcher(const NGramFst &fst, MatchType match_type) + : owned_fst_(fst.Copy()), + fst_(*owned_fst_), + inst_(fst_.inst_), + match_type_(match_type), + current_loop_(false), + loop_(kNoLabel, 0, A::Weight::One(), kNoStateId) { + if (match_type_ == MATCH_OUTPUT) { + std::swap(loop_.ilabel, loop_.olabel); + } + } + + // This doesn't copy the FST. + NGramFstMatcher(const NGramFst *fst, MatchType match_type) + : fst_(*fst), + inst_(fst_.inst_), + match_type_(match_type), + current_loop_(false), + loop_(kNoLabel, 0, A::Weight::One(), kNoStateId) { + if (match_type_ == MATCH_OUTPUT) { + std::swap(loop_.ilabel, loop_.olabel); + } + } + + // This makes a copy of the FST. + NGramFstMatcher(const NGramFstMatcher &matcher, bool safe = false) + : owned_fst_(matcher.fst_.Copy(safe)), + fst_(*owned_fst_), + inst_(matcher.inst_), + match_type_(matcher.match_type_), + current_loop_(false), + loop_(kNoLabel, 0, A::Weight::One(), kNoStateId) { + if (match_type_ == MATCH_OUTPUT) { + std::swap(loop_.ilabel, loop_.olabel); + } + } + + NGramFstMatcher *Copy(bool safe = false) const override { + return new NGramFstMatcher(*this, safe); + } + + MatchType Type(bool test) const override { return match_type_; } + + const Fst &GetFst() const override { return fst_; } + + uint64 Properties(uint64 props) const override { return props; } + + void SetState(StateId s) final { + fst_.GetImpl()->SetInstFuture(s, &inst_); + current_loop_ = false; + } + + bool Find(Label label) final { + const Label nolabel = kNoLabel; + done_ = true; + if (label == 0 || label == nolabel) { + if (label == 0) { + current_loop_ = true; + loop_.nextstate = inst_.state_; + } + // The unigram state has no epsilon arc. + if (inst_.state_ != 0) { + arc_.ilabel = arc_.olabel = 0; + fst_.GetImpl()->SetInstNode(&inst_); + arc_.nextstate = fst_.GetImpl()->context_index_.Rank1( + fst_.GetImpl()->context_index_.Select1( + fst_.GetImpl()->context_index_.Rank0(inst_.node_) - 1)); + arc_.weight = fst_.GetImpl()->backoff_[inst_.state_]; + done_ = false; + } + } else { + current_loop_ = false; + const Label *start = fst_.GetImpl()->future_words_ + inst_.offset_; + const Label *end = start + inst_.num_futures_; + const Label *search = std::lower_bound(start, end, label); + if (search != end && *search == label) { + size_t state = search - start; + arc_.ilabel = arc_.olabel = label; + arc_.weight = fst_.GetImpl()->future_probs_[inst_.offset_ + state]; + fst_.GetImpl()->SetInstContext(&inst_); + arc_.nextstate = fst_.GetImpl()->Transition(inst_.context_, label); + done_ = false; + } + } + return !Done(); + } + + bool Done() const final { return !current_loop_ && done_; } + + const Arc &Value() const final { return (current_loop_) ? loop_ : arc_; } + + void Next() final { + if (current_loop_) { + current_loop_ = false; + } else { + done_ = true; + } + } + + ssize_t Priority(StateId s) final { return fst_.NumArcs(s); } + + private: + std::unique_ptr> owned_fst_; + const NGramFst &fst_; + NGramFstInst inst_; + MatchType match_type_; // Supplied by caller + bool done_; + Arc arc_; + bool current_loop_; // Current arc is the implicit loop + Arc loop_; +}; + +/*****************************************************************************/ +// Specialization for NGramFst; see generic version in fst.h +// for sample usage (but use the ProdLmFst type!). This version +// should inline. +template +class StateIterator> : public StateIteratorBase { + public: + typedef typename A::StateId StateId; + + explicit StateIterator(const NGramFst &fst) + : s_(0), num_states_(fst.NumStates()) {} + + bool Done() const final { return s_ >= num_states_; } + + StateId Value() const final { return s_; } + + void Next() final { ++s_; } + + void Reset() final { s_ = 0; } + + private: + StateId s_; + StateId num_states_; +}; + +/*****************************************************************************/ +template +class ArcIterator> : public ArcIteratorBase { + public: + typedef A Arc; + typedef typename A::Label Label; + typedef typename A::StateId StateId; + typedef typename A::Weight Weight; + + ArcIterator(const NGramFst &fst, StateId state) + : lazy_(~0), impl_(fst.GetImpl()), i_(0), flags_(kArcValueFlags) { + inst_ = fst.inst_; + impl_->SetInstFuture(state, &inst_); + impl_->SetInstNode(&inst_); + } + + bool Done() const final { + return i_ >= + ((inst_.node_ == 0) ? inst_.num_futures_ : inst_.num_futures_ + 1); + } + + const Arc &Value() const final { + bool eps = (inst_.node_ != 0 && i_ == 0); + StateId state = (inst_.node_ == 0) ? i_ : i_ - 1; + if (flags_ & lazy_ & (kArcILabelValue | kArcOLabelValue)) { + arc_.ilabel = arc_.olabel = + eps ? 0 : impl_->future_words_[inst_.offset_ + state]; + lazy_ &= ~(kArcILabelValue | kArcOLabelValue); + } + if (flags_ & lazy_ & kArcNextStateValue) { + if (eps) { + arc_.nextstate = + impl_->context_index_.Rank1(impl_->context_index_.Select1( + impl_->context_index_.Rank0(inst_.node_) - 1)); + } else { + if (lazy_ & kArcNextStateValue) { + impl_->SetInstContext(&inst_); // first time only. + } + arc_.nextstate = impl_->Transition( + inst_.context_, impl_->future_words_[inst_.offset_ + state]); + } + lazy_ &= ~kArcNextStateValue; + } + if (flags_ & lazy_ & kArcWeightValue) { + arc_.weight = eps ? impl_->backoff_[inst_.state_] + : impl_->future_probs_[inst_.offset_ + state]; + lazy_ &= ~kArcWeightValue; + } + return arc_; + } + + void Next() final { + ++i_; + lazy_ = ~0; + } + + size_t Position() const final { return i_; } + + void Reset() final { + i_ = 0; + lazy_ = ~0; + } + + void Seek(size_t a) final { + if (i_ != a) { + i_ = a; + lazy_ = ~0; + } + } + + uint32 Flags() const final { return flags_; } + + void SetFlags(uint32 flags, uint32 mask) final { + flags_ &= ~mask; + flags_ |= (flags & kArcValueFlags); + } + + private: + mutable Arc arc_; + mutable uint32 lazy_; + const internal::NGramFstImpl *impl_; // Borrowed reference. + mutable NGramFstInst inst_; + + size_t i_; + uint32 flags_; +}; + +} // namespace fst +#endif // FST_EXTENSIONS_NGRAM_NGRAM_FST_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/ngram/nthbit.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/ngram/nthbit.h new file mode 100644 index 0000000000..83253219bf --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/ngram/nthbit.h @@ -0,0 +1,32 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_EXTENSIONS_NGRAM_NTHBIT_H_ +#define FST_EXTENSIONS_NGRAM_NTHBIT_H_ + +#include + +extern uint32 nth_bit_bit_offset[]; + +inline uint32 nth_bit(uint64 v, uint32 r) { + uint32 shift = 0; + uint32 c = __builtin_popcount(v & 0xffffffff); + uint32 mask = -(r > c); + r -= c & mask; + shift += (32 & mask); + + c = __builtin_popcount((v >> shift) & 0xffff); + mask = -(r > c); + r -= c & mask; + shift += (16 & mask); + + c = __builtin_popcount((v >> shift) & 0xff); + mask = -(r > c); + r -= c & mask; + shift += (8 & mask); + + return shift + + ((nth_bit_bit_offset[(v >> shift) & 0xff] >> ((r - 1) << 2)) & 0xf); +} + +#endif // FST_EXTENSIONS_NGRAM_NTHBIT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/pdt/collection.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/pdt/collection.h new file mode 100644 index 0000000000..ae34aba7ed --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/pdt/collection.h @@ -0,0 +1,107 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Class to store a collection of ordered (multi-)sets with elements of type T. + +#ifndef FST_EXTENSIONS_PDT_COLLECTION_H_ +#define FST_EXTENSIONS_PDT_COLLECTION_H_ + +#include +#include + +#include +#include + +namespace fst { + +// Stores a collection of non-empty, ordered (multi-)sets with elements of type +// T. A default constructor, operator==, and an STL-style hash functor must be +// defined on the elements. Provides signed integer ID (of type I) for each +// unique set. The IDs are allocated starting from 0 in order. +template +class Collection { + public: + struct Node { // Trie node. + I node_id; // Root is kNoNodeId; + T element; + + Node() : node_id(kNoNodeId), element(T()) {} + + Node(I i, const T &t) : node_id(i), element(t) {} + + bool operator==(const Node &n) const { + return n.node_id == node_id && n.element == element; + } + }; + + struct NodeHash { + size_t operator()(const Node &n) const { + static constexpr auto kPrime = 7853; + return n.node_id + hash_(n.element) * kPrime; + } + }; + + using NodeTable = CompactHashBiTable; + + class SetIterator { + public: + SetIterator(I id, Node node, NodeTable *node_table) + : id_(id), node_(node), node_table_(node_table) {} + + bool Done() const { return id_ == kNoNodeId; } + + const T &Element() const { return node_.element; } + + void Next() { + id_ = node_.node_id; + if (id_ != kNoNodeId) node_ = node_table_->FindEntry(id_); + } + + private: + I id_; // Iterator set node ID. + Node node_; // Iterator set node. + NodeTable *node_table_; + }; + + Collection() {} + + // Looks up integer ID from ordered multi-se, and if it doesn't exist and + // insert is true, then adds it. Otherwise returns -1. + I FindId(const std::vector &set, bool insert = true) { + I node_id = kNoNodeId; + for (ssize_t i = set.size() - 1; i >= 0; --i) { + Node node(node_id, set[i]); + node_id = node_table_.FindId(node, insert); + if (node_id == -1) break; + } + return node_id; + } + + // Finds ordered (multi-)set given integer ID. Returns set iterator to + // traverse result. + SetIterator FindSet(I id) { + if (id < 0 || id >= node_table_.Size()) { + return SetIterator(kNoNodeId, Node(kNoNodeId, T()), &node_table_); + } else { + return SetIterator(id, node_table_.FindEntry(id), &node_table_); + } + } + + I Size() const { return node_table_.Size(); } + + private: + static constexpr I kNoNodeId = -1; + static const std::hash hash_; + + NodeTable node_table_; +}; + +template +constexpr I Collection::kNoNodeId; + +template +const std::hash Collection::hash_ = {}; + +} // namespace fst + +#endif // FST_EXTENSIONS_PDT_COLLECTION_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/pdt/compose.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/pdt/compose.h new file mode 100644 index 0000000000..525d613a7a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/pdt/compose.h @@ -0,0 +1,493 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Composes a PDT and an FST. + +#ifndef FST_EXTENSIONS_PDT_COMPOSE_H_ +#define FST_EXTENSIONS_PDT_COMPOSE_H_ + +#include + +#include +#include + +namespace fst { + +// Returns paren arcs for Find(kNoLabel). +constexpr uint32 kParenList = 0x00000001; + +// Returns a kNolabel loop for Find(paren). +constexpr uint32 kParenLoop = 0x00000002; + +// This class is a matcher that treats parens as multi-epsilon labels. +// It is most efficient if the parens are in a range non-overlapping with +// the non-paren labels. +template +class ParenMatcher { + public: + using FST = F; + using M = SortedMatcher; + using Arc = typename FST::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + // This makes a copy of the FST. + ParenMatcher(const FST &fst, MatchType match_type, + uint32 flags = (kParenLoop | kParenList)) + : matcher_(fst, match_type), match_type_(match_type), flags_(flags) { + if (match_type == MATCH_INPUT) { + loop_.ilabel = kNoLabel; + loop_.olabel = 0; + } else { + loop_.ilabel = 0; + loop_.olabel = kNoLabel; + } + loop_.weight = Weight::One(); + loop_.nextstate = kNoStateId; + } + + // This doesn't copy the FST. + ParenMatcher(const FST *fst, MatchType match_type, + uint32 flags = (kParenLoop | kParenList)) + : matcher_(fst, match_type), match_type_(match_type), flags_(flags) { + if (match_type == MATCH_INPUT) { + loop_.ilabel = kNoLabel; + loop_.olabel = 0; + } else { + loop_.ilabel = 0; + loop_.olabel = kNoLabel; + } + loop_.weight = Weight::One(); + loop_.nextstate = kNoStateId; + } + + // This makes a copy of the FST. + ParenMatcher(const ParenMatcher &matcher, bool safe = false) + : matcher_(matcher.matcher_, safe), + match_type_(matcher.match_type_), + flags_(matcher.flags_), + open_parens_(matcher.open_parens_), + close_parens_(matcher.close_parens_), + loop_(matcher.loop_) { + loop_.nextstate = kNoStateId; + } + + ParenMatcher *Copy(bool safe = false) const { + return new ParenMatcher(*this, safe); + } + + MatchType Type(bool test) const { return matcher_.Type(test); } + + void SetState(StateId s) { + matcher_.SetState(s); + loop_.nextstate = s; + } + + bool Find(Label match_label); + + bool Done() const { return done_; } + + const Arc &Value() const { return paren_loop_ ? loop_ : matcher_.Value(); } + + void Next(); + + Weight Final(StateId s) { return matcher_.Final(s); } + + ssize_t Priority(StateId s) { return matcher_.Priority(s); } + + const FST &GetFst() const { return matcher_.GetFst(); } + + uint64 Properties(uint64 props) const { return matcher_.Properties(props); } + + uint32 Flags() const { return matcher_.Flags(); } + + void AddOpenParen(Label label) { + if (label == 0) { + FSTERROR() << "ParenMatcher: Bad open paren label: 0"; + } else { + open_parens_.Insert(label); + } + } + + void AddCloseParen(Label label) { + if (label == 0) { + FSTERROR() << "ParenMatcher: Bad close paren label: 0"; + } else { + close_parens_.Insert(label); + } + } + + void RemoveOpenParen(Label label) { + if (label == 0) { + FSTERROR() << "ParenMatcher: Bad open paren label: 0"; + } else { + open_parens_.Erase(label); + } + } + + void RemoveCloseParen(Label label) { + if (label == 0) { + FSTERROR() << "ParenMatcher: Bad close paren label: 0"; + } else { + close_parens_.Erase(label); + } + } + + void ClearOpenParens() { open_parens_.Clear(); } + + void ClearCloseParens() { close_parens_.Clear(); } + + bool IsOpenParen(Label label) const { return open_parens_.Member(label); } + + bool IsCloseParen(Label label) const { return close_parens_.Member(label); } + + private: + // Advances matcher to next open paren, returning true if it exists. + bool NextOpenParen(); + + // Advances matcher to next close paren, returning true if it exists. + bool NextCloseParen(); + + M matcher_; + MatchType match_type_; // Type of match to perform. + uint32 flags_; + // Open paren label set. + CompactSet open_parens_; + // Close paren label set. + CompactSet close_parens_; + bool open_paren_list_; // Matching open paren list? + bool close_paren_list_; // Matching close paren list? + bool paren_loop_; // Current arc is the implicit paren loop? + mutable Arc loop_; // For non-consuming symbols. + bool done_; // Matching done? + + ParenMatcher &operator=(const ParenMatcher &) = delete; +}; + +template +inline bool ParenMatcher::Find(Label match_label) { + open_paren_list_ = false; + close_paren_list_ = false; + paren_loop_ = false; + done_ = false; + // Returns all parenthesis arcs. + if (match_label == kNoLabel && (flags_ & kParenList)) { + if (open_parens_.LowerBound() != kNoLabel) { + matcher_.LowerBound(open_parens_.LowerBound()); + open_paren_list_ = NextOpenParen(); + if (open_paren_list_) return true; + } + if (close_parens_.LowerBound() != kNoLabel) { + matcher_.LowerBound(close_parens_.LowerBound()); + close_paren_list_ = NextCloseParen(); + if (close_paren_list_) return true; + } + } + // Returns the implicit paren loop. + if (match_label > 0 && (flags_ & kParenLoop) && + (IsOpenParen(match_label) || IsCloseParen(match_label))) { + paren_loop_ = true; + return true; + } + // Returns all other labels. + if (matcher_.Find(match_label)) return true; + done_ = true; + return false; +} + +template +inline void ParenMatcher::Next() { + if (paren_loop_) { + paren_loop_ = false; + done_ = true; + } else if (open_paren_list_) { + matcher_.Next(); + open_paren_list_ = NextOpenParen(); + if (open_paren_list_) return; + if (close_parens_.LowerBound() != kNoLabel) { + matcher_.LowerBound(close_parens_.LowerBound()); + close_paren_list_ = NextCloseParen(); + if (close_paren_list_) return; + } + done_ = !matcher_.Find(kNoLabel); + } else if (close_paren_list_) { + matcher_.Next(); + close_paren_list_ = NextCloseParen(); + if (close_paren_list_) return; + done_ = !matcher_.Find(kNoLabel); + } else { + matcher_.Next(); + done_ = matcher_.Done(); + } +} + +// Advances matcher to next open paren, returning true if it exists. +template +inline bool ParenMatcher::NextOpenParen() { + for (; !matcher_.Done(); matcher_.Next()) { + Label label = match_type_ == MATCH_INPUT ? matcher_.Value().ilabel + : matcher_.Value().olabel; + if (label > open_parens_.UpperBound()) return false; + if (IsOpenParen(label)) return true; + } + return false; +} + +// Advances matcher to next close paren, returning true if it exists. +template +inline bool ParenMatcher::NextCloseParen() { + for (; !matcher_.Done(); matcher_.Next()) { + Label label = match_type_ == MATCH_INPUT ? matcher_.Value().ilabel + : matcher_.Value().olabel; + if (label > close_parens_.UpperBound()) return false; + if (IsCloseParen(label)) return true; + } + return false; +} + +template +class ParenFilter { + public: + using FST1 = typename Filter::FST1; + using FST2 = typename Filter::FST2; + using Arc = typename Filter::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using Matcher1 = typename Filter::Matcher1; + using Matcher2 = typename Filter::Matcher2; + + using StackId = StateId; + using ParenStack = PdtStack; + using FilterState1 = typename Filter::FilterState; + using FilterState2 = IntegerFilterState; + using FilterState = PairFilterState; + + ParenFilter(const FST1 &fst1, const FST2 &fst2, Matcher1 *matcher1 = nullptr, + Matcher2 *matcher2 = nullptr, + const std::vector> *parens = nullptr, + bool expand = false, bool keep_parens = true) + : filter_(fst1, fst2, matcher1, matcher2), + parens_(parens ? *parens : std::vector>()), + expand_(expand), + keep_parens_(keep_parens), + fs_(FilterState::NoState()), + stack_(parens_), + paren_id_(-1) { + if (parens) { + for (const auto &pair : *parens) { + parens_.push_back(pair); + GetMatcher1()->AddOpenParen(pair.first); + GetMatcher2()->AddOpenParen(pair.first); + if (!expand_) { + GetMatcher1()->AddCloseParen(pair.second); + GetMatcher2()->AddCloseParen(pair.second); + } + } + } + } + + ParenFilter(const ParenFilter &filter, bool safe = false) + : filter_(filter.filter_, safe), + parens_(filter.parens_), + expand_(filter.expand_), + keep_parens_(filter.keep_parens_), + fs_(FilterState::NoState()), + stack_(filter.parens_), + paren_id_(-1) {} + + FilterState Start() const { + return FilterState(filter_.Start(), FilterState2(0)); + } + + void SetState(StateId s1, StateId s2, const FilterState &fs) { + fs_ = fs; + filter_.SetState(s1, s2, fs_.GetState1()); + if (!expand_) return; + ssize_t paren_id = stack_.Top(fs.GetState2().GetState()); + if (paren_id != paren_id_) { + if (paren_id_ != -1) { + GetMatcher1()->RemoveCloseParen(parens_[paren_id_].second); + GetMatcher2()->RemoveCloseParen(parens_[paren_id_].second); + } + paren_id_ = paren_id; + if (paren_id_ != -1) { + GetMatcher1()->AddCloseParen(parens_[paren_id_].second); + GetMatcher2()->AddCloseParen(parens_[paren_id_].second); + } + } + } + + FilterState FilterArc(Arc *arc1, Arc *arc2) const { + const auto fs1 = filter_.FilterArc(arc1, arc2); + const auto &fs2 = fs_.GetState2(); + if (fs1 == FilterState1::NoState()) return FilterState::NoState(); + if (arc1->olabel == kNoLabel && arc2->ilabel) { // arc2 parentheses. + if (keep_parens_) { + arc1->ilabel = arc2->ilabel; + } else if (arc2->ilabel) { + arc2->olabel = arc1->ilabel; + } + return FilterParen(arc2->ilabel, fs1, fs2); + } else if (arc2->ilabel == kNoLabel && arc1->olabel) { // arc1 parentheses. + if (keep_parens_) { + arc2->olabel = arc1->olabel; + } else { + arc1->ilabel = arc2->olabel; + } + return FilterParen(arc1->olabel, fs1, fs2); + } else { + return FilterState(fs1, fs2); + } + } + + void FilterFinal(Weight *w1, Weight *w2) const { + if (fs_.GetState2().GetState() != 0) *w1 = Weight::Zero(); + filter_.FilterFinal(w1, w2); + } + + // Returns respective matchers; ownership stays with filter. + + Matcher1 *GetMatcher1() { return filter_.GetMatcher1(); } + + Matcher2 *GetMatcher2() { return filter_.GetMatcher2(); } + + uint64 Properties(uint64 iprops) const { + return filter_.Properties(iprops) & kILabelInvariantProperties & + kOLabelInvariantProperties; + } + + private: + const FilterState FilterParen(Label label, const FilterState1 &fs1, + const FilterState2 &fs2) const { + if (!expand_) return FilterState(fs1, fs2); + const auto stack_id = stack_.Find(fs2.GetState(), label); + if (stack_id < 0) { + return FilterState::NoState(); + } else { + return FilterState(fs1, FilterState2(stack_id)); + } + } + + Filter filter_; + std::vector> parens_; + bool expand_; // Expands to FST? + bool keep_parens_; // Retains parentheses in output? + FilterState fs_; // Current filter state. + mutable ParenStack stack_; + ssize_t paren_id_; +}; + +// Class to setup composition options for PDT composition. Default is to take +// the PDT as the first composition argument. +template +class PdtComposeFstOptions + : public ComposeFstOptions< + Arc, ParenMatcher>, + ParenFilter>>>> { + public: + using Label = typename Arc::Label; + using PdtMatcher = ParenMatcher>; + using PdtFilter = ParenFilter>; + + using ComposeFstOptions::matcher1; + using ComposeFstOptions::matcher2; + using ComposeFstOptions::filter; + + PdtComposeFstOptions(const Fst &ifst1, + const std::vector> &parens, + const Fst &ifst2, bool expand = false, + bool keep_parens = true) { + matcher1 = new PdtMatcher(ifst1, MATCH_OUTPUT, kParenList); + matcher2 = new PdtMatcher(ifst2, MATCH_INPUT, kParenLoop); + filter = new PdtFilter(ifst1, ifst2, matcher1, matcher2, &parens, expand, + keep_parens); + } +}; + +// Class to setup composition options for PDT with FST composition. +// Specialization is for the FST as the first composition argument. +template +class PdtComposeFstOptions + : public ComposeFstOptions< + Arc, ParenMatcher>, + ParenFilter>>>> { + public: + using Label = typename Arc::Label; + using PdtMatcher = ParenMatcher>; + using PdtFilter = ParenFilter>; + + using ComposeFstOptions::matcher1; + using ComposeFstOptions::matcher2; + using ComposeFstOptions::filter; + + PdtComposeFstOptions(const Fst &ifst1, const Fst &ifst2, + const std::vector> &parens, + bool expand = false, bool keep_parens = true) { + matcher1 = new PdtMatcher(ifst1, MATCH_OUTPUT, kParenLoop); + matcher2 = new PdtMatcher(ifst2, MATCH_INPUT, kParenList); + filter = new PdtFilter(ifst1, ifst2, matcher1, matcher2, &parens, expand, + keep_parens); + } +}; + +enum PdtComposeFilter { + PAREN_FILTER, // Bar-Hillel construction; keeps parentheses. + EXPAND_FILTER, // Bar-Hillel + expansion; removes parentheses. + EXPAND_PAREN_FILTER, // Bar-Hillel + expansion; keeps parentheses. +}; + +struct PdtComposeOptions { + bool connect; // Connect output? + PdtComposeFilter filter_type; // Pre-defined filter to use. + + explicit PdtComposeOptions(bool connect = true, + PdtComposeFilter filter_type = PAREN_FILTER) + : connect(connect), filter_type(filter_type) {} +}; + +// Composes pushdown transducer (PDT) encoded as an FST (1st arg) and an FST +// (2nd arg) with the result also a PDT encoded as an FST (3rd arg). In the +// PDTs, some transitions are labeled with open or close parentheses. To be +// interpreted as a PDT, the parens must balance on a path (see PdtExpand()). +// The open-close parenthesis label pairs are passed using the parens argument. +template +void Compose(const Fst &ifst1, + const std::vector< + std::pair> &parens, + const Fst &ifst2, MutableFst *ofst, + const PdtComposeOptions &opts = PdtComposeOptions()) { + bool expand = opts.filter_type != PAREN_FILTER; + bool keep_parens = opts.filter_type != EXPAND_FILTER; + PdtComposeFstOptions copts(ifst1, parens, ifst2, expand, + keep_parens); + copts.gc_limit = 0; + *ofst = ComposeFst(ifst1, ifst2, copts); + if (opts.connect) Connect(ofst); +} + +// Composes an FST (1st arg) and pushdown transducer (PDT) encoded as an FST +// (2nd arg) with the result also a PDT encoded as an FST (3rd arg). In the +// PDTs, some transitions are labeled with open or close parentheses. To be +// interpreted as a PDT, the parens must balance on a path (see ExpandFst()). +// The open-close parenthesis label pairs are passed using the parens argument. +template +void Compose(const Fst &ifst1, const Fst &ifst2, + const std::vector< + std::pair> &parens, + MutableFst *ofst, + const PdtComposeOptions &opts = PdtComposeOptions()) { + bool expand = opts.filter_type != PAREN_FILTER; + bool keep_parens = opts.filter_type != EXPAND_FILTER; + PdtComposeFstOptions copts(ifst1, ifst2, parens, expand, + keep_parens); + copts.gc_limit = 0; + *ofst = ComposeFst(ifst1, ifst2, copts); + if (opts.connect) Connect(ofst); +} + +} // namespace fst + +#endif // FST_EXTENSIONS_PDT_COMPOSE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/pdt/expand.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/pdt/expand.h new file mode 100644 index 0000000000..eeee781e4b --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/pdt/expand.h @@ -0,0 +1,933 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Expands a PDT to an FST. + +#ifndef FST_EXTENSIONS_PDT_EXPAND_H_ +#define FST_EXTENSIONS_PDT_EXPAND_H_ + +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace fst { + +template +struct PdtExpandFstOptions : public CacheOptions { + bool keep_parentheses; + PdtStack *stack; + PdtStateTable *state_table; + + explicit PdtExpandFstOptions( + const CacheOptions &opts = CacheOptions(), bool keep_parentheses = false, + PdtStack *stack = nullptr, + PdtStateTable *state_table = + nullptr) + : CacheOptions(opts), + keep_parentheses(keep_parentheses), + stack(stack), + state_table(state_table) {} +}; + +namespace internal { + +// Implementation class for PdtExpandFst. +template +class PdtExpandFstImpl : public CacheImpl { + public: + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using StackId = StateId; + using StateTuple = PdtStateTuple; + + using FstImpl::SetType; + using FstImpl::SetProperties; + using FstImpl::Properties; + using FstImpl::SetInputSymbols; + using FstImpl::SetOutputSymbols; + + using CacheBaseImpl>::PushArc; + using CacheBaseImpl>::HasArcs; + using CacheBaseImpl>::HasFinal; + using CacheBaseImpl>::HasStart; + using CacheBaseImpl>::SetArcs; + using CacheBaseImpl>::SetFinal; + using CacheBaseImpl>::SetStart; + + PdtExpandFstImpl(const Fst &fst, + const std::vector> &parens, + const PdtExpandFstOptions &opts) + : CacheImpl(opts), + fst_(fst.Copy()), + stack_(opts.stack ? opts.stack : new PdtStack(parens)), + state_table_(opts.state_table ? opts.state_table + : new PdtStateTable()), + own_stack_(opts.stack == 0), + own_state_table_(opts.state_table == 0), + keep_parentheses_(opts.keep_parentheses) { + SetType("expand"); + const auto props = fst.Properties(kFstProperties, false); + SetProperties(PdtExpandProperties(props), kCopyProperties); + SetInputSymbols(fst.InputSymbols()); + SetOutputSymbols(fst.OutputSymbols()); + } + + PdtExpandFstImpl(const PdtExpandFstImpl &impl) + : CacheImpl(impl), + fst_(impl.fst_->Copy(true)), + stack_(new PdtStack(*impl.stack_)), + state_table_(new PdtStateTable()), + own_stack_(true), + own_state_table_(true), + keep_parentheses_(impl.keep_parentheses_) { + SetType("expand"); + SetProperties(impl.Properties(), kCopyProperties); + SetInputSymbols(impl.InputSymbols()); + SetOutputSymbols(impl.OutputSymbols()); + } + + ~PdtExpandFstImpl() override { + if (own_stack_) delete stack_; + if (own_state_table_) delete state_table_; + } + + StateId Start() { + if (!HasStart()) { + const auto s = fst_->Start(); + if (s == kNoStateId) return kNoStateId; + StateTuple tuple(s, 0); + const auto start = state_table_->FindState(tuple); + SetStart(start); + } + return CacheImpl::Start(); + } + + Weight Final(StateId s) { + if (!HasFinal(s)) { + const auto &tuple = state_table_->Tuple(s); + const auto weight = fst_->Final(tuple.state_id); + if (weight != Weight::Zero() && tuple.stack_id == 0) + SetFinal(s, weight); + else + SetFinal(s, Weight::Zero()); + } + return CacheImpl::Final(s); + } + + size_t NumArcs(StateId s) { + if (!HasArcs(s)) ExpandState(s); + return CacheImpl::NumArcs(s); + } + + size_t NumInputEpsilons(StateId s) { + if (!HasArcs(s)) ExpandState(s); + return CacheImpl::NumInputEpsilons(s); + } + + size_t NumOutputEpsilons(StateId s) { + if (!HasArcs(s)) ExpandState(s); + return CacheImpl::NumOutputEpsilons(s); + } + + void InitArcIterator(StateId s, ArcIteratorData *data) { + if (!HasArcs(s)) ExpandState(s); + CacheImpl::InitArcIterator(s, data); + } + + // Computes the outgoing transitions from a state, creating new destination + // states as needed. + void ExpandState(StateId s) { + StateTuple tuple = state_table_->Tuple(s); + for (ArcIterator> aiter(*fst_, tuple.state_id); !aiter.Done(); + aiter.Next()) { + auto arc = aiter.Value(); + const auto stack_id = stack_->Find(tuple.stack_id, arc.ilabel); + if (stack_id == -1) { // Non-matching close parenthesis. + continue; + } else if ((stack_id != tuple.stack_id) && !keep_parentheses_) { + // Stack push/pop. + arc.ilabel = 0; + arc.olabel = 0; + } + StateTuple ntuple(arc.nextstate, stack_id); + arc.nextstate = state_table_->FindState(ntuple); + PushArc(s, arc); + } + SetArcs(s); + } + + const PdtStack &GetStack() const { return *stack_; } + + const PdtStateTable &GetStateTable() const { + return *state_table_; + } + + private: + // Properties for an expanded PDT. + inline uint64 PdtExpandProperties(uint64 inprops) { + return inprops & (kAcceptor | kAcyclic | kInitialAcyclic | kUnweighted); + } + + std::unique_ptr> fst_; + PdtStack *stack_; + PdtStateTable *state_table_; + bool own_stack_; + bool own_state_table_; + bool keep_parentheses_; +}; + +} // namespace internal + +// Expands a pushdown transducer (PDT) encoded as an FST into an FST. This +// version is a delayed FST. In the PDT, some transitions are labeled with open +// or close parentheses. To be interpreted as a PDT, the parens must balance on +// a path. The open-close parenthesis label pairs are passed using the parens +// argument. The expansion enforces the parenthesis constraints. The PDT must be +// expandable as an FST. +// +// This class attaches interface to implementation and handles reference +// counting, delegating most methods to ImplToFst. +template +class PdtExpandFst : public ImplToFst> { + public: + using Arc = A; + + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using StackId = StateId; + using Store = DefaultCacheStore; + using State = typename Store::State; + using Impl = internal::PdtExpandFstImpl; + + friend class ArcIterator>; + friend class StateIterator>; + + PdtExpandFst(const Fst &fst, + const std::vector> &parens) + : ImplToFst( + std::make_shared(fst, parens, PdtExpandFstOptions())) {} + + PdtExpandFst(const Fst &fst, + const std::vector> &parens, + const PdtExpandFstOptions &opts) + : ImplToFst(std::make_shared(fst, parens, opts)) {} + + // See Fst<>::Copy() for doc. + PdtExpandFst(const PdtExpandFst &fst, bool safe = false) + : ImplToFst(fst, safe) {} + + // Gets a copy of this ExpandFst. See Fst<>::Copy() for further doc. + PdtExpandFst *Copy(bool safe = false) const override { + return new PdtExpandFst(*this, safe); + } + + inline void InitStateIterator(StateIteratorData *data) const override; + + void InitArcIterator(StateId s, ArcIteratorData *data) const override { + GetMutableImpl()->InitArcIterator(s, data); + } + + const PdtStack &GetStack() const { + return GetImpl()->GetStack(); + } + + const PdtStateTable &GetStateTable() const { + return GetImpl()->GetStateTable(); + } + + private: + using ImplToFst::GetImpl; + using ImplToFst::GetMutableImpl; + + void operator=(const PdtExpandFst &) = delete; +}; + +// Specialization for PdtExpandFst. +template +class StateIterator> + : public CacheStateIterator> { + public: + explicit StateIterator(const PdtExpandFst &fst) + : CacheStateIterator>(fst, fst.GetMutableImpl()) {} +}; + +// Specialization for PdtExpandFst. +template +class ArcIterator> + : public CacheArcIterator> { + public: + using StateId = typename Arc::StateId; + + ArcIterator(const PdtExpandFst &fst, StateId s) + : CacheArcIterator>(fst.GetMutableImpl(), s) { + if (!fst.GetImpl()->HasArcs(s)) fst.GetMutableImpl()->ExpandState(s); + } +}; + +template +inline void PdtExpandFst::InitStateIterator( + StateIteratorData *data) const { + data->base = new StateIterator>(*this); +} + +// PrunedExpand prunes the delayed expansion of a pushdown transducer (PDT) +// encoded as an FST into an FST. In the PDT, some transitions are labeled with +// open or close parentheses. To be interpreted as a PDT, the parens must +// balance on a path. The open-close parenthesis label pairs are passed +// using the parens argument. The expansion enforces the parenthesis +// constraints. +// +// The algorithm works by visiting the delayed ExpandFst using a shortest-stack +// first queue discipline and relies on the shortest-distance information +// computed using a reverse shortest-path call to perform the pruning. +// +// The algorithm maintains the same state ordering between the ExpandFst being +// visited (efst_) and the result of pruning written into the MutableFst (ofst_) +// to improve readability. +template +class PdtPrunedExpand { + public: + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using StackId = StateId; + using Stack = PdtStack; + using StateTable = PdtStateTable; + using SetIterator = typename internal::PdtBalanceData::SetIterator; + + // Constructor taking as input a PDT specified by by an input FST and a vector + // of parentheses. The keep_parentheses argument specifies whether parentheses + // are replaced by epsilons or not during the expansion. The cache options are + // passed to the underlying ExpandFst. + PdtPrunedExpand(const Fst &ifst, + const std::vector> &parens, + bool keep_parentheses = false, + const CacheOptions &opts = CacheOptions()) + : ifst_(ifst.Copy()), + keep_parentheses_(keep_parentheses), + stack_(parens), + efst_(ifst, parens, + PdtExpandFstOptions(opts, true, &stack_, &state_table_)), + queue_(state_table_, stack_, stack_length_, distance_, fdistance_), + error_(false) { + Reverse(*ifst_, parens, &rfst_); + VectorFst path; + reverse_shortest_path_.reset(new PdtShortestPath>( + rfst_, parens, + PdtShortestPathOptions>(true, false))); + reverse_shortest_path_->ShortestPath(&path); + error_ = (path.Properties(kError, true) == kError); + balance_data_.reset(reverse_shortest_path_->GetBalanceData()->Reverse( + rfst_.NumStates(), 10, -1)); + InitCloseParenMultimap(parens); + } + + bool Error() const { return error_; } + + // Expands and prunes the input PDT according to the provided weight + // threshold, wirting the result into an output mutable FST. + void Expand(MutableFst *ofst, const Weight &threshold); + + private: + static constexpr uint8 kEnqueued = 0x01; + static constexpr uint8 kExpanded = 0x02; + static constexpr uint8 kSourceState = 0x04; + + // Comparison functor used by the queue: + // + // 1. States corresponding to shortest stack first, and + // 2. for stacks of matching length, reverse lexicographic order is used, and + // 3. for states with the same stack, shortest-first order is used. + class StackCompare { + public: + StackCompare(const StateTable &state_table, const Stack &stack, + const std::vector &stack_length, + const std::vector &distance, + const std::vector &fdistance) + : state_table_(state_table), + stack_(stack), + stack_length_(stack_length), + distance_(distance), + fdistance_(fdistance) {} + + bool operator()(StateId s1, StateId s2) const { + auto si1 = state_table_.Tuple(s1).stack_id; + auto si2 = state_table_.Tuple(s2).stack_id; + if (stack_length_[si1] < stack_length_[si2]) return true; + if (stack_length_[si1] > stack_length_[si2]) return false; + // If stack IDs are equal, use A*. + if (si1 == si2) { + return less_(Distance(s1), Distance(s2)); + } + // If lengths are equal, uses reverse lexicographic order. + for (; si1 != si2; si1 = stack_.Pop(si1), si2 = stack_.Pop(si2)) { + if (stack_.Top(si1) < stack_.Top(si2)) return true; + if (stack_.Top(si1) > stack_.Top(si2)) return false; + } + return false; + } + + private: + Weight Distance(StateId s) const { + return (s < distance_.size()) && (s < fdistance_.size()) + ? Times(distance_[s], fdistance_[s]) + : Weight::Zero(); + } + + const StateTable &state_table_; + const Stack &stack_; + const std::vector &stack_length_; + const std::vector &distance_; + const std::vector &fdistance_; + const NaturalLess less_; + }; + + class ShortestStackFirstQueue + : public ShortestFirstQueue { + public: + ShortestStackFirstQueue(const PdtStateTable &state_table, + const Stack &stack, + const std::vector &stack_length, + const std::vector &distance, + const std::vector &fdistance) + : ShortestFirstQueue(StackCompare( + state_table, stack, stack_length, distance, fdistance)) {} + }; + + void InitCloseParenMultimap( + const std::vector> &parens); + + Weight DistanceToDest(StateId source, StateId dest) const; + + uint8 Flags(StateId s) const; + + void SetFlags(StateId s, uint8 flags, uint8 mask); + + Weight Distance(StateId s) const; + + void SetDistance(StateId s, Weight weight); + + Weight FinalDistance(StateId s) const; + + void SetFinalDistance(StateId s, Weight weight); + + StateId SourceState(StateId s) const; + + void SetSourceState(StateId s, StateId p); + + void AddStateAndEnqueue(StateId s); + + void Relax(StateId s, const Arc &arc, Weight weight); + + bool PruneArc(StateId s, const Arc &arc); + + void ProcStart(); + + void ProcFinal(StateId s); + + bool ProcNonParen(StateId s, const Arc &arc, bool add_arc); + + bool ProcOpenParen(StateId s, const Arc &arc, StackId si, StackId nsi); + + bool ProcCloseParen(StateId s, const Arc &arc); + + void ProcDestStates(StateId s, StackId si); + + // Input PDT. + std::unique_ptr> ifst_; + // Reversed PDT. + VectorFst rfst_; + // Keep parentheses in ofst? + const bool keep_parentheses_; + // State table for efst_. + StateTable state_table_; + // Stack trie. + Stack stack_; + // Expanded PDT. + PdtExpandFst efst_; + // Length of stack for given stack ID. + std::vector stack_length_; + // Distance from initial state in efst_/ofst. + std::vector distance_; + // Distance to final states in efst_/ofst. + std::vector fdistance_; + // Queue used to visit efst_. + ShortestStackFirstQueue queue_; + // Construction time failure? + bool error_; + // Status flags for states in efst_/ofst. + std::vector flags_; + // PDT source state for each expanded state. + std::vector sources_; + // Shortest path for rfst_. + std::unique_ptr>> + reverse_shortest_path_; + std::unique_ptr> balance_data_; + // Maps open paren arcs to balancing close paren arcs. + typename PdtShortestPath>::CloseParenMultimap + close_paren_multimap_; + MutableFst *ofst_; // Output FST. + Weight limit_; // Weight limit. + + // Maps a state s in ifst (i.e., the source of a closed paranthesis matching + // the top of current_stack_id_ to final states in efst_. + std::unordered_map dest_map_; + // Stack ID of the states currently at the top of the queue, i.e., the states + // currently being popped and processed. + StackId current_stack_id_; + ssize_t current_paren_id_; // Paren ID at top of current stack. + ssize_t cached_stack_id_; + StateId cached_source_; + // The set of pairs of destination states and weights to final states for the + // source state cached_source_ and the paren ID cached_paren_id_; i.e., the + // set of source states of a closed parenthesis with paren ID cached_paren_id + // balancing an incoming open parenthesis with paren ID cached_paren_id_ in + // state cached_source_. + std::forward_list> cached_dest_list_; + NaturalLess less_; +}; + +// Initializes close paren multimap, mapping pairs (s, paren_id) to all the arcs +// out of s labeled with close parenthese for paren_id. +template +void PdtPrunedExpand::InitCloseParenMultimap( + const std::vector> &parens) { + std::unordered_map paren_map; + for (size_t i = 0; i < parens.size(); ++i) { + const auto &pair = parens[i]; + paren_map[pair.first] = i; + paren_map[pair.second] = i; + } + for (StateIterator> siter(*ifst_); !siter.Done(); siter.Next()) { + const auto s = siter.Value(); + for (ArcIterator> aiter(*ifst_, s); !aiter.Done(); aiter.Next()) { + const auto &arc = aiter.Value(); + const auto it = paren_map.find(arc.ilabel); + if (it == paren_map.end()) continue; + if (arc.ilabel == parens[it->second].second) { // Close paren. + const internal::ParenState key(it->second, s); + close_paren_multimap_.emplace(key, arc); + } + } + } +} + +// Returns the weight of the shortest balanced path from source to dest +// in ifst_; dest must be the source state of a close paren arc. +template +typename Arc::Weight PdtPrunedExpand::DistanceToDest(StateId source, + StateId dest) const { + using SearchState = + typename PdtShortestPath>::SearchState; + const SearchState ss(source + 1, dest + 1); + const auto distance = + reverse_shortest_path_->GetShortestPathData().Distance(ss); + VLOG(2) << "D(" << source << ", " << dest << ") =" << distance; + return distance; +} + +// Returns the flags for state s in ofst_. +template +uint8 PdtPrunedExpand::Flags(StateId s) const { + return s < flags_.size() ? flags_[s] : 0; +} + +// Modifies the flags for state s in ofst_. +template +void PdtPrunedExpand::SetFlags(StateId s, uint8 flags, uint8 mask) { + while (flags_.size() <= s) flags_.push_back(0); + flags_[s] &= ~mask; + flags_[s] |= flags & mask; +} + +// Returns the shortest distance from the initial state to s in ofst_. +template +typename Arc::Weight PdtPrunedExpand::Distance(StateId s) const { + return s < distance_.size() ? distance_[s] : Weight::Zero(); +} + +// Sets the shortest distance from the initial state to s in ofst_. +template +void PdtPrunedExpand::SetDistance(StateId s, Weight weight) { + while (distance_.size() <= s) distance_.push_back(Weight::Zero()); + distance_[s] = std::move(weight); +} + +// Returns the shortest distance from s to the final states in ofst_. +template +typename Arc::Weight PdtPrunedExpand::FinalDistance(StateId s) const { + return s < fdistance_.size() ? fdistance_[s] : Weight::Zero(); +} + +// Sets the shortest distance from s to the final states in ofst_. +template +void PdtPrunedExpand::SetFinalDistance(StateId s, Weight weight) { + while (fdistance_.size() <= s) fdistance_.push_back(Weight::Zero()); + fdistance_[s] = std::move(weight); +} + +// Returns the PDT source state of state s in ofst_. +template +typename Arc::StateId PdtPrunedExpand::SourceState(StateId s) const { + return s < sources_.size() ? sources_[s] : kNoStateId; +} + +// Sets the PDT source state of state s in ofst_ to state p'in ifst_. +template +void PdtPrunedExpand::SetSourceState(StateId s, StateId p) { + while (sources_.size() <= s) sources_.push_back(kNoStateId); + sources_[s] = p; +} + +// Adds state s of efst_ to ofst_ and inserts it in the queue, modifying the +// flags for s accordingly. +template +void PdtPrunedExpand::AddStateAndEnqueue(StateId s) { + if (!(Flags(s) & (kEnqueued | kExpanded))) { + while (ofst_->NumStates() <= s) ofst_->AddState(); + queue_.Enqueue(s); + SetFlags(s, kEnqueued, kEnqueued); + } else if (Flags(s) & kEnqueued) { + queue_.Update(s); + } + // TODO(allauzen): Check everything is fine when kExpanded? +} + +// Relaxes arc out of state s in ofst_ as follows: +// +// 1. If the distance to s times the weight of arc is smaller than +// the currently stored distance for arc.nextstate, updates +// Distance(arc.nextstate) with a new estimate +// 2. If fd is less than the currently stored distance from arc.nextstate to the +// final state, updates with new estimate. +template +void PdtPrunedExpand::Relax(StateId s, const Arc &arc, Weight fd) { + const auto nd = Times(Distance(s), arc.weight); + if (less_(nd, Distance(arc.nextstate))) { + SetDistance(arc.nextstate, nd); + SetSourceState(arc.nextstate, SourceState(s)); + } + if (less_(fd, FinalDistance(arc.nextstate))) { + SetFinalDistance(arc.nextstate, fd); + } + VLOG(2) << "Relax: " << s << ", d[s] = " << Distance(s) << ", to " + << arc.nextstate << ", d[ns] = " << Distance(arc.nextstate) + << ", nd = " << nd; +} + +// Returns whether the arc out of state s in efst needs pruned. +template +bool PdtPrunedExpand::PruneArc(StateId s, const Arc &arc) { + VLOG(2) << "Prune ?"; + auto fd = Weight::Zero(); + if ((cached_source_ != SourceState(s)) || + (cached_stack_id_ != current_stack_id_)) { + cached_source_ = SourceState(s); + cached_stack_id_ = current_stack_id_; + cached_dest_list_.clear(); + if (cached_source_ != ifst_->Start()) { + for (auto set_iter = + balance_data_->Find(current_paren_id_, cached_source_); + !set_iter.Done(); set_iter.Next()) { + auto dest = set_iter.Element(); + const auto it = dest_map_.find(dest); + cached_dest_list_.push_front(*it); + } + } else { + // TODO(allauzen): queue discipline should prevent this from ever + // happening. + // Replace by a check. + cached_dest_list_.push_front( + std::make_pair(rfst_.Start() - 1, Weight::One())); + } + } + for (auto it = cached_dest_list_.begin(); it != cached_dest_list_.end(); + ++it) { + const auto d = + DistanceToDest(state_table_.Tuple(arc.nextstate).state_id, it->first); + fd = Plus(fd, Times(d, it->second)); + } + Relax(s, arc, fd); + return less_(limit_, Times(Distance(s), Times(arc.weight, fd))); +} + +// Adds start state of efst_ to ofst_, enqueues it, and initializes the distance +// data structures. +template +void PdtPrunedExpand::ProcStart() { + const auto s = efst_.Start(); + AddStateAndEnqueue(s); + ofst_->SetStart(s); + SetSourceState(s, ifst_->Start()); + current_stack_id_ = 0; + current_paren_id_ = -1; + stack_length_.push_back(0); + const auto r = rfst_.Start() - 1; + cached_source_ = ifst_->Start(); + cached_stack_id_ = 0; + cached_dest_list_.push_front(std::make_pair(r, Weight::One())); + const PdtStateTuple tuple(r, 0); + SetFinalDistance(state_table_.FindState(tuple), Weight::One()); + SetDistance(s, Weight::One()); + const auto d = DistanceToDest(ifst_->Start(), r); + SetFinalDistance(s, d); + VLOG(2) << d; +} + +// Makes s final in ofst_ if shortest accepting path ending in s is below +// threshold. +template +void PdtPrunedExpand::ProcFinal(StateId s) { + const auto weight = efst_.Final(s); + if (weight == Weight::Zero()) return; + if (less_(limit_, Times(Distance(s), weight))) return; + ofst_->SetFinal(s, weight); +} + +// Returns true when an arc (or meta-arc) leaving state s in efst_ is below the +// threshold. When add_arc is true, arc is added to ofst_. +template +bool PdtPrunedExpand::ProcNonParen(StateId s, const Arc &arc, + bool add_arc) { + VLOG(2) << "ProcNonParen: " << s << " to " << arc.nextstate << ", " + << arc.ilabel << ":" << arc.olabel << " / " << arc.weight + << ", add_arc = " << (add_arc ? "true" : "false"); + if (PruneArc(s, arc)) return false; + if (add_arc) ofst_->AddArc(s, arc); + AddStateAndEnqueue(arc.nextstate); + return true; +} + +// Processes an open paren arc leaving state s in ofst_. When the arc is labeled +// with an open paren, +// +// 1. Considers each (shortest) balanced path starting in s by taking the arc +// and ending by a close paren balancing the open paren of as a meta-arc, +// processing and pruning each meta-arc as a non-paren arc, inserting its +// destination to the queue; +// 2. if at least one of these meta-arcs has not been pruned, adds the +// destination of arc to ofst_ as a new source state for the stack ID nsi, and +// inserts it in the queue. +template +bool PdtPrunedExpand::ProcOpenParen(StateId s, const Arc &arc, StackId si, + StackId nsi) { + // Updates the stack length when needed. + while (stack_length_.size() <= nsi) stack_length_.push_back(-1); + if (stack_length_[nsi] == -1) stack_length_[nsi] = stack_length_[si] + 1; + const auto ns = arc.nextstate; + VLOG(2) << "Open paren: " << s << "(" << state_table_.Tuple(s).state_id + << ") to " << ns << "(" << state_table_.Tuple(ns).state_id << ")"; + bool proc_arc = false; + auto fd = Weight::Zero(); + const auto paren_id = stack_.ParenId(arc.ilabel); + std::forward_list sources; + for (auto set_iter = + balance_data_->Find(paren_id, state_table_.Tuple(ns).state_id); + !set_iter.Done(); set_iter.Next()) { + sources.push_front(set_iter.Element()); + } + for (const auto source : sources) { + VLOG(2) << "Close paren source: " << source; + const internal::ParenState paren_state(paren_id, source); + for (auto it = close_paren_multimap_.find(paren_state); + it != close_paren_multimap_.end() && paren_state == it->first; ++it) { + auto meta_arc = it->second; + const PdtStateTuple tuple(meta_arc.nextstate, si); + meta_arc.nextstate = state_table_.FindState(tuple); + const auto state_id = state_table_.Tuple(ns).state_id; + const auto d = DistanceToDest(state_id, source); + VLOG(2) << state_id << ", " << source; + VLOG(2) << "Meta arc weight = " << arc.weight << " Times " << d + << " Times " << meta_arc.weight; + meta_arc.weight = Times(arc.weight, Times(d, meta_arc.weight)); + proc_arc |= ProcNonParen(s, meta_arc, false); + fd = Plus( + fd, + Times(Times(DistanceToDest(state_table_.Tuple(ns).state_id, source), + it->second.weight), + FinalDistance(meta_arc.nextstate))); + } + } + if (proc_arc) { + VLOG(2) << "Proc open paren " << s << " to " << arc.nextstate; + ofst_->AddArc( + s, keep_parentheses_ ? arc : Arc(0, 0, arc.weight, arc.nextstate)); + AddStateAndEnqueue(arc.nextstate); + const auto nd = Times(Distance(s), arc.weight); + if (less_(nd, Distance(arc.nextstate))) SetDistance(arc.nextstate, nd); + // FinalDistance not necessary for source state since pruning decided using + // meta-arcs above. But this is a problem with A*, hence the following. + if (less_(fd, FinalDistance(arc.nextstate))) + SetFinalDistance(arc.nextstate, fd); + SetFlags(arc.nextstate, kSourceState, kSourceState); + } + return proc_arc; +} + +// Checks that shortest path through close paren arc in efst_ is below +// threshold, and if so, adds it to ofst_. +template +bool PdtPrunedExpand::ProcCloseParen(StateId s, const Arc &arc) { + const auto weight = + Times(Distance(s), Times(arc.weight, FinalDistance(arc.nextstate))); + if (less_(limit_, weight)) return false; + ofst_->AddArc(s, + keep_parentheses_ ? arc : Arc(0, 0, arc.weight, arc.nextstate)); + return true; +} + +// When state s in ofst_ is a source state for stack ID si, identifies all the +// corresponding possible destination states, that is, all the states in ifst_ +// that have an outgoing close paren arc balancing the incoming open paren taken +// to get to s. For each such state t, computes the shortest distance from (t, +// si) to the final states in ofst_. Stores this information in dest_map_. +template +void PdtPrunedExpand::ProcDestStates(StateId s, StackId si) { + if (!(Flags(s) & kSourceState)) return; + if (si != current_stack_id_) { + dest_map_.clear(); + current_stack_id_ = si; + current_paren_id_ = stack_.Top(current_stack_id_); + VLOG(2) << "StackID " << si << " dequeued for first time"; + } + // TODO(allauzen): clean up source state business; rename current function to + // ProcSourceState. + SetSourceState(s, state_table_.Tuple(s).state_id); + const auto paren_id = stack_.Top(si); + for (auto set_iter = + balance_data_->Find(paren_id, state_table_.Tuple(s).state_id); + !set_iter.Done(); set_iter.Next()) { + const auto dest_state = set_iter.Element(); + if (dest_map_.find(dest_state) != dest_map_.end()) continue; + auto dest_weight = Weight::Zero(); + internal::ParenState paren_state(paren_id, dest_state); + for (auto it = close_paren_multimap_.find(paren_state); + it != close_paren_multimap_.end() && paren_state == it->first; ++it) { + const auto &arc = it->second; + const PdtStateTuple tuple(arc.nextstate, + stack_.Pop(si)); + dest_weight = + Plus(dest_weight, + Times(arc.weight, FinalDistance(state_table_.FindState(tuple)))); + } + dest_map_[dest_state] = dest_weight; + VLOG(2) << "State " << dest_state << " is a dest state for stack ID " << si + << " with weight " << dest_weight; + } +} + +// Expands and prunes the input PDT, writing the result in ofst. +template +void PdtPrunedExpand::Expand(MutableFst *ofst, + const typename Arc::Weight &threshold) { + ofst_ = ofst; + if (error_) { + ofst_->SetProperties(kError, kError); + return; + } + ofst_->DeleteStates(); + ofst_->SetInputSymbols(ifst_->InputSymbols()); + ofst_->SetOutputSymbols(ifst_->OutputSymbols()); + limit_ = Times(DistanceToDest(ifst_->Start(), rfst_.Start() - 1), threshold); + flags_.clear(); + ProcStart(); + while (!queue_.Empty()) { + const auto s = queue_.Head(); + queue_.Dequeue(); + SetFlags(s, kExpanded, kExpanded | kEnqueued); + VLOG(2) << s << " dequeued!"; + ProcFinal(s); + StackId stack_id = state_table_.Tuple(s).stack_id; + ProcDestStates(s, stack_id); + for (ArcIterator> aiter(efst_, s); !aiter.Done(); + aiter.Next()) { + const auto &arc = aiter.Value(); + const auto nextstack_id = state_table_.Tuple(arc.nextstate).stack_id; + if (stack_id == nextstack_id) { + ProcNonParen(s, arc, true); + } else if (stack_id == stack_.Pop(nextstack_id)) { + ProcOpenParen(s, arc, stack_id, nextstack_id); + } else { + ProcCloseParen(s, arc); + } + } + VLOG(2) << "d[" << s << "] = " << Distance(s) << ", fd[" << s + << "] = " << FinalDistance(s); + } +} + +// Expand functions. + +template +struct PdtExpandOptions { + using Weight = typename Arc::Weight; + + bool connect; + bool keep_parentheses; + Weight weight_threshold; + + PdtExpandOptions(bool connect = true, bool keep_parentheses = false, + Weight weight_threshold = Weight::Zero()) + : connect(connect), + keep_parentheses(keep_parentheses), + weight_threshold(std::move(weight_threshold)) {} +}; + +// Expands a pushdown transducer (PDT) encoded as an FST into an FST. This +// version writes the expanded PDT to a mutable FST. In the PDT, some +// transitions are labeled with open or close parentheses. To be interpreted as +// a PDT, the parens must balance on a path. The open-close parenthesis label +// pairs are passed using the parens argument. Expansion enforces the +// parenthesis constraints. The PDT must be expandable as an FST. +template +void Expand( + const Fst &ifst, + const std::vector> + &parens, + MutableFst *ofst, const PdtExpandOptions &opts) { + PdtExpandFstOptions eopts; + eopts.gc_limit = 0; + if (opts.weight_threshold == Arc::Weight::Zero()) { + eopts.keep_parentheses = opts.keep_parentheses; + *ofst = PdtExpandFst(ifst, parens, eopts); + } else { + PdtPrunedExpand pruned_expand(ifst, parens, opts.keep_parentheses); + pruned_expand.Expand(ofst, opts.weight_threshold); + } + if (opts.connect) Connect(ofst); +} + +// Expands a pushdown transducer (PDT) encoded as an FST into an FST. This +// version writes the expanded PDT result to a mutable FST. In the PDT, some +// transitions are labeled with open or close parentheses. To be interpreted as +// a PDT, the parens must balance on a path. The open-close parenthesis label +// pairs are passed using the parents argument. Expansion enforces the +// parenthesis constraints. The PDT must be expandable as an FST. +template +void Expand(const Fst &ifst, + const std::vector> + &parens, MutableFst *ofst, bool connect = true, + bool keep_parentheses = false) { + const PdtExpandOptions opts(connect, keep_parentheses); + Expand(ifst, parens, ofst, opts); +} + +} // namespace fst + +#endif // FST_EXTENSIONS_PDT_EXPAND_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/pdt/getters.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/pdt/getters.h new file mode 100644 index 0000000000..69dd150db6 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/pdt/getters.h @@ -0,0 +1,22 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_EXTENSIONS_PDT_GETTERS_H_ +#define FST_EXTENSIONS_PDT_GETTERS_H_ + +#include + +#include +#include + +namespace fst { +namespace script { + +bool GetPdtComposeFilter(const string &str, PdtComposeFilter *cf); + +bool GetPdtParserType(const string &str, PdtParserType *pt); + +} // namespace script +} // namespace fst + +#endif // FST_EXTENSIONS_PDT_GETTERS_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/pdt/info.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/pdt/info.h new file mode 100644 index 0000000000..3de547721f --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/extensions/pdt/info.h @@ -0,0 +1,152 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Prints information about a PDT. + +#ifndef FST_EXTENSIONS_PDT_INFO_H_ +#define FST_EXTENSIONS_PDT_INFO_H_ + +#include +#include +#include + +#include +#include + +namespace fst { + +// Compute various information about PDTs. +template +class PdtInfo { + public: + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + PdtInfo(const Fst &fst, + const std::vector> &parents); + + const string &FstType() const { return fst_type_; } + + const string &ArcType() const { return Arc::Type(); } + + int64 NumStates() const { return nstates_; } + + int64 NumArcs() const { return narcs_; } + + int64 NumOpenParens() const { return nopen_parens_; } + + int64 NumCloseParens() const { return nclose_parens_; } + + int64 NumUniqueOpenParens() const { return nuniq_open_parens_; } + + int64 NumUniqueCloseParens() const { return nuniq_close_parens_; } + + int64 NumOpenParenStates() const { return nopen_paren_states_; } + + int64 NumCloseParenStates() const { return nclose_paren_states_; } + + private: + string fst_type_; + int64 nstates_; + int64 narcs_; + int64 nopen_parens_; + int64 nclose_parens_; + int64 nuniq_open_parens_; + int64 nuniq_close_parens_; + int64 nopen_paren_states_; + int64 nclose_paren_states_; +}; + +template +PdtInfo::PdtInfo( + const Fst &fst, + const std::vector> + &parens) + : fst_type_(fst.Type()), + nstates_(0), + narcs_(0), + nopen_parens_(0), + nclose_parens_(0), + nuniq_open_parens_(0), + nuniq_close_parens_(0), + nopen_paren_states_(0), + nclose_paren_states_(0) { + std::unordered_map paren_map; + std::unordered_set { + public: + using Arc = A; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using ComposeFst::CreateBase; + using ComposeFst::CreateBase1; + using ComposeFst::Properties; + + IntersectFst(const Fst &fst1, const Fst &fst2, + const CacheOptions &opts = CacheOptions()) + : ComposeFst(CreateBase(fst1, fst2, opts)) { + const bool acceptors = + fst1.Properties(kAcceptor, true) && fst2.Properties(kAcceptor, true); + if (!acceptors) { + FSTERROR() << "IntersectFst: Input FSTs are not acceptors"; + GetMutableImpl()->SetProperties(kError); + } + } + + template + IntersectFst(const Fst &fst1, const Fst &fst2, + const IntersectFstOptions &opts) + : ComposeFst(CreateBase1(fst1, fst2, opts)) { + const bool acceptors = + fst1.Properties(kAcceptor, true) && fst2.Properties(kAcceptor, true); + if (!acceptors) { + FSTERROR() << "IntersectFst: input FSTs are not acceptors"; + GetMutableImpl()->SetProperties(kError); + } + } + + // See Fst<>::Copy() for doc. + IntersectFst(const IntersectFst &fst, bool safe = false) + : ComposeFst(fst, safe) {} + + // Get a copy of this IntersectFst. See Fst<>::Copy() for further doc. + IntersectFst *Copy(bool safe = false) const override { + return new IntersectFst(*this, safe); + } + + private: + using ImplToFst>::GetImpl; + using ImplToFst>::GetMutableImpl; +}; + +// Specialization for IntersectFst. +template +class StateIterator> : public StateIterator> { + public: + explicit StateIterator(const IntersectFst &fst) + : StateIterator>(fst) {} +}; + +// Specialization for IntersectFst. +template +class ArcIterator> : public ArcIterator> { + public: + using StateId = typename Arc::StateId; + + ArcIterator(const IntersectFst &fst, StateId s) + : ArcIterator>(fst, s) {} +}; + +// Useful alias when using StdArc. +using StdIntersectFst = IntersectFst; + +// Computes the intersection (Hadamard product) of two FSAs. This version +// writes the intersection to an output MurableFst. Only strings that are in +// both automata are retained in the result. +// +// The two arguments must be acceptors. One of the arguments must be +// label-sorted. +// +// Complexity: same as Compose. +// +// Caveats: same as Compose. +template +void Intersect(const Fst &ifst1, const Fst &ifst2, + MutableFst *ofst, + const IntersectOptions &opts = IntersectOptions()) { + using M = Matcher>; + if (opts.filter_type == AUTO_FILTER) { + CacheOptions nopts; + nopts.gc_limit = 0; // Cache only the last state for fastest copy. + *ofst = IntersectFst(ifst1, ifst2, nopts); + } else if (opts.filter_type == SEQUENCE_FILTER) { + IntersectFstOptions iopts; + iopts.gc_limit = 0; // Cache only the last state for fastest copy. + *ofst = IntersectFst(ifst1, ifst2, iopts); + } else if (opts.filter_type == ALT_SEQUENCE_FILTER) { + IntersectFstOptions> iopts; + iopts.gc_limit = 0; // Cache only the last state for fastest copy. + *ofst = IntersectFst(ifst1, ifst2, iopts); + } else if (opts.filter_type == MATCH_FILTER) { + IntersectFstOptions> iopts; + iopts.gc_limit = 0; // Cache only the last state for fastest copy. + *ofst = IntersectFst(ifst1, ifst2, iopts); + } + if (opts.connect) Connect(ofst); +} + +} // namespace fst + +#endif // FST_INTERSECT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/interval-set.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/interval-set.h new file mode 100644 index 0000000000..0942ea0016 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/interval-set.h @@ -0,0 +1,398 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Class to represent and operate on sets of intervals. + +#ifndef FST_INTERVAL_SET_H_ +#define FST_INTERVAL_SET_H_ + +#include +#include +#include + + +#include + + +namespace fst { + +// Half-open integral interval [a, b) of signed integers of type T. +template +struct IntInterval { + T begin; + T end; + + IntInterval() : begin(-1), end(-1) {} + + IntInterval(T begin, T end) : begin(begin), end(end) {} + + bool operator<(const IntInterval &i) const { + return begin < i.begin || (begin == i.begin && end > i.end); + } + + bool operator==(const IntInterval &i) const { + return begin == i.begin && end == i.end; + } + + bool operator!=(const IntInterval &i) const { + return begin != i.begin || end != i.end; + } + + std::istream &Read(std::istream &strm) { + T n; + ReadType(strm, &n); + begin = n; + ReadType(strm, &n); + end = n; + return strm; + } + + std::ostream &Write(std::ostream &strm) const { + T n = begin; + WriteType(strm, n); + n = end; + WriteType(strm, n); + return strm; + } +}; + +// Stores IntIntervals in a vector. In addition, keeps the count of points in +// all intervals. +template +class VectorIntervalStore { + public: + using Interval = IntInterval; + using Iterator = typename std::vector::const_iterator; + + VectorIntervalStore() : count_(-1) {} + + std::vector *MutableIntervals() { return &intervals_; } + + const Interval *Intervals() const { return intervals_.data(); } + + T Size() const { return intervals_.size(); } + + T Count() const { return count_; } + + void SetCount(T count) { count_ = count; } + + void Clear() { + intervals_.clear(); + count_ = 0; + } + + Iterator begin() const { return intervals_.begin(); } + + Iterator end() const { return intervals_.end(); } + + std::istream &Read(std::istream &strm) { + ReadType(strm, &intervals_); + return ReadType(strm, &count_); + } + + std::ostream &Write(std::ostream &strm) const { + WriteType(strm, intervals_); + return WriteType(strm, count_); + } + + private: + std::vector intervals_; + T count_; +}; + +// Stores and operates on a set of half-open integral intervals [a, b) +// of signed integers of type T. +template > +class IntervalSet { + public: + using Interval = IntInterval; + + template + explicit IntervalSet(A... args) : intervals_(args...) {} + + // Returns the interval set as a vector. + std::vector *MutableIntervals() { + return intervals_.MutableIntervals(); + } + + // Returns a pointer to an array of Size() elements. + const Interval *Intervals() const { return intervals_.Intervals(); } + + bool Empty() const { return Size() == 0; } + + T Size() const { return intervals_.Size(); } + + // Number of points in the intervals (undefined if not normalized). + T Count() const { return intervals_.Count(); } + + void Clear() { intervals_.Clear(); } + + // Adds an interval set to the set. The result may not be normalized. + void Union(const IntervalSet &iset) { + intervals_.MutableIntervals()->insert(intervals_.MutableIntervals()->end(), + iset.intervals_.begin(), + iset.intervals_.end()); + } + + // Requires intervals be normalized. + bool Member(T value) const { + const Interval interval(value, value); + auto lb = std::lower_bound(intervals_.begin(), intervals_.end(), interval); + if (lb == intervals_.begin()) return false; + return (--lb)->end > value; + } + + // Requires intervals be normalized. + bool operator==(const IntervalSet &iset) const { + return Size() == iset.Size() && + std::equal(intervals_.begin(), intervals_.end(), + iset.intervals_.begin()); + } + + // Requires intervals be normalized. + bool operator!=(const IntervalSet &iset) const { + return Size() != iset.Size() || + !std::equal(intervals_.begin(), intervals_.end(), + iset.intervals_.begin()); + } + + bool Singleton() const { + return Size() == 1 && + intervals_.begin()->begin + 1 == intervals_.begin()->end; + } + + // Sorts, collapses overlapping and adjacent interals, and sets count. + void Normalize(); + + // Intersects an interval set with the set. Requires intervals be normalized. + // The result is normalized. + void Intersect(const IntervalSet &iset, + IntervalSet *oset) const; + + // Complements the set w.r.t [0, maxval). Requires intervals be normalized. + // The result is normalized. + void Complement(T maxval, IntervalSet *oset) const; + + // Subtract an interval set from the set. Requires intervals be normalized. + // The result is normalized. + void Difference(const IntervalSet &iset, + IntervalSet *oset) const; + + // Determines if an interval set overlaps with the set. Requires intervals be + // normalized. + bool Overlaps(const IntervalSet &iset) const; + + // Determines if an interval set overlaps with the set but neither is + // contained in the other. Requires intervals be normalized. + bool StrictlyOverlaps(const IntervalSet &iset) const; + + // Determines if an interval set is contained within the set. Requires + // intervals be normalized. + bool Contains(const IntervalSet &iset) const; + + std::istream &Read(std::istream &strm) { return intervals_.Read(strm); } + + std::ostream &Write(std::ostream &strm) const { + return intervals_.Write(strm); + } + + typename Store::Iterator begin() const { return intervals_.begin(); } + + typename Store::Iterator end() const { return intervals_.end(); } + + private: + Store intervals_; +}; + +// Sorts, collapses overlapping and adjacent intervals, and sets count. +template +void IntervalSet::Normalize() { + auto &intervals = *intervals_.MutableIntervals(); + std::sort(intervals.begin(), intervals.end()); + T count = 0; + T size = 0; + for (T i = 0; i < intervals.size(); ++i) { + auto &inti = intervals[i]; + if (inti.begin == inti.end) continue; + for (T j = i + 1; j < intervals.size(); ++j) { + auto &intj = intervals[j]; + if (intj.begin > inti.end) break; + if (intj.end > inti.end) inti.end = intj.end; + ++i; + } + count += inti.end - inti.begin; + intervals[size++] = inti; + } + intervals.resize(size); + intervals_.SetCount(count); +} + +// Intersects an interval set with the set. Requires intervals be normalized. +// The result is normalized. +template +void IntervalSet::Intersect(const IntervalSet &iset, + IntervalSet *oset) const { + auto *ointervals = oset->MutableIntervals(); + auto it1 = intervals_.begin(); + auto it2 = iset.intervals_.begin(); + ointervals->clear(); + T count = 0; + while (it1 != intervals_.end() && it2 != iset.intervals_.end()) { + if (it1->end <= it2->begin) { + ++it1; + } else if (it2->end <= it1->begin) { + ++it2; + } else { + ointervals->emplace_back(std::max(it1->begin, it2->begin), + std::min(it1->end, it2->end)); + count += ointervals->back().end - ointervals->back().begin; + if (it1->end < it2->end) { + ++it1; + } else { + ++it2; + } + } + } + oset->intervals_.SetCount(count); +} + +// Complements the set w.r.t [0, maxval). Requires intervals be normalized. +// The result is normalized. +template +void IntervalSet::Complement(T maxval, + IntervalSet *oset) const { + auto *ointervals = oset->MutableIntervals(); + ointervals->clear(); + T count = 0; + Interval interval; + interval.begin = 0; + for (auto it = intervals_.begin(); it != intervals_.end(); ++it) { + interval.end = std::min(it->begin, maxval); + if ((interval.begin) < (interval.end)) { + ointervals->push_back(interval); + count += interval.end - interval.begin; + } + interval.begin = it->end; + } + interval.end = maxval; + if ((interval.begin) < (interval.end)) { + ointervals->push_back(interval); + count += interval.end - interval.begin; + } + oset->intervals_.SetCount(count); +} + +// Subtract an interval set from the set. Requires intervals be normalized. +// The result is normalized. +template +void IntervalSet::Difference(const IntervalSet &iset, + IntervalSet *oset) const { + if (Empty()) { + oset->MutableIntervals()->clear(); + oset->intervals_.SetCount(0); + } else { + IntervalSet cset; + iset.Complement(intervals_.Intervals()[intervals_.Size() - 1].end, &cset); + Intersect(cset, oset); + } +} + +// Determines if an interval set overlaps with the set. Requires intervals be +// normalized. +template +bool IntervalSet::Overlaps(const IntervalSet &iset) const { + auto it1 = intervals_.begin(); + auto it2 = iset.intervals_.begin(); + while (it1 != intervals_.end() && it2 != iset.intervals_.end()) { + if (it1->end <= it2->begin) { + ++it1; + } else if (it2->end <= it1->begin) { + ++it2; + } else { + return true; + } + } + return false; +} + +// Determines if an interval set overlaps with the set but neither is contained +// in the other. Requires intervals be normalized. +template +bool IntervalSet::StrictlyOverlaps( + const IntervalSet &iset) const { + auto it1 = intervals_.begin(); + auto it2 = iset.intervals_.begin(); + bool only1 = false; // Point in intervals_ but not intervals. + bool only2 = false; // Point in intervals but not intervals_. + bool overlap = false; // Point in both intervals_ and intervals. + while (it1 != intervals_.end() && it2 != iset.intervals_.end()) { + if (it1->end <= it2->begin) { // no overlap - it1 first + only1 = true; + ++it1; + } else if (it2->end <= it1->begin) { // no overlap - it2 first + only2 = true; + ++it2; + } else if (it2->begin == it1->begin && it2->end == it1->end) { // equals + overlap = true; + ++it1; + ++it2; + } else if (it2->begin <= it1->begin && it2->end >= it1->end) { // 1 c 2 + only2 = true; + overlap = true; + ++it1; + } else if (it1->begin <= it2->begin && it1->end >= it2->end) { // 2 c 1 + only1 = true; + overlap = true; + ++it2; + } else { // Strict overlap. + only1 = true; + only2 = true; + overlap = true; + } + if (only1 == true && only2 == true && overlap == true) return true; + } + if (it1 != intervals_.end()) only1 = true; + if (it2 != iset.intervals_.end()) only2 = true; + return only1 == true && only2 == true && overlap == true; +} + +// Determines if an interval set is contained within the set. Requires intervals +// be normalized. +template +bool IntervalSet::Contains(const IntervalSet &iset) const { + if (iset.Count() > Count()) return false; + auto it1 = intervals_.begin(); + auto it2 = iset.intervals_.begin(); + while (it1 != intervals_.end() && it2 != iset.intervals_.end()) { + if ((it1->end) <= (it2->begin)) { // No overlap; it1 first. + ++it1; + } else if ((it2->begin) < (it1->begin) || + (it2->end) > (it1->end)) { // No C. + return false; + } else if (it2->end == it1->end) { + ++it1; + ++it2; + } else { + ++it2; + } + } + return it2 == iset.intervals_.end(); +} + +template +std::ostream &operator<<(std::ostream &strm, const IntervalSet &s) { + strm << "{"; + for (T i = 0; i < s.Size(); ++i) { + if (i > 0) { + strm << ","; + } + const auto &interval = s.Intervals()[i]; + strm << "[" << interval.begin << "," << interval.end << ")"; + } + strm << "}"; + return strm; +} + +} // namespace fst + +#endif // FST_INTERVAL_SET_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/invert.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/invert.h new file mode 100644 index 0000000000..bd243c6271 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/invert.h @@ -0,0 +1,139 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Functions and classes to invert an FST. + +#ifndef FST_INVERT_H_ +#define FST_INVERT_H_ + +#include +#include + + +namespace fst { + +// Mapper to implement inversion of an arc. +template +struct InvertMapper { + using FromArc = A; + using ToArc = A; + + InvertMapper() {} + + ToArc operator()(const FromArc &arc) const { + return ToArc(arc.olabel, arc.ilabel, arc.weight, arc.nextstate); + } + + constexpr MapFinalAction FinalAction() const { + return MAP_NO_SUPERFINAL; + } + + constexpr MapSymbolsAction InputSymbolsAction() const { + return MAP_CLEAR_SYMBOLS; + } + + constexpr MapSymbolsAction OutputSymbolsAction() const { + return MAP_CLEAR_SYMBOLS; + } + + uint64 Properties(uint64 props) const { + return InvertProperties(props); + } +}; + +// Inverts the transduction corresponding to an FST by exchanging the +// FST's input and output labels. +// +// Complexity: +// +// Time: O(V + E) +// Space: O(1) +// +// where V is the number of states and E is the number of arcs. +template +inline void Invert(const Fst &ifst, MutableFst *ofst) { + std::unique_ptr input( + ifst.InputSymbols() ? ifst.InputSymbols()->Copy() : nullptr); + std::unique_ptr output( + ifst.OutputSymbols() ? ifst.OutputSymbols()->Copy() : nullptr); + ArcMap(ifst, ofst, InvertMapper()); + ofst->SetInputSymbols(output.get()); + ofst->SetOutputSymbols(input.get()); +} + +// Destructive variant of the above. +template +inline void Invert(MutableFst *fst) { + std::unique_ptr input( + fst->InputSymbols() ? fst->InputSymbols()->Copy() : nullptr); + std::unique_ptr output( + fst->OutputSymbols() ? fst->OutputSymbols()->Copy() : nullptr); + ArcMap(fst, InvertMapper()); + fst->SetInputSymbols(output.get()); + fst->SetOutputSymbols(input.get()); +} + +// Inverts the transduction corresponding to an FST by exchanging the +// FST's input and output labels. This version is a delayed FST. +// +// Complexity: +// +// Time: O(v + e) +// Space: O(1) +// +// where v is the number of states visited and e is the number of arcs visited. +// Constant time and to visit an input state or arc is assumed and exclusive of +// caching. +template +class InvertFst : public ArcMapFst> { + public: + using Arc = A; + + using Mapper = InvertMapper; + using Impl = internal::ArcMapFstImpl>; + + explicit InvertFst(const Fst &fst) + : ArcMapFst(fst, Mapper()) { + GetMutableImpl()->SetOutputSymbols(fst.InputSymbols()); + GetMutableImpl()->SetInputSymbols(fst.OutputSymbols()); + } + + // See Fst<>::Copy() for doc. + InvertFst(const InvertFst &fst, bool safe = false) + : ArcMapFst(fst, safe) {} + + // Get a copy of this InvertFst. See Fst<>::Copy() for further doc. + InvertFst *Copy(bool safe = false) const override { + return new InvertFst(*this, safe); + } + + private: + using ImplToFst::GetMutableImpl; +}; + +// Specialization for InvertFst. +template +class StateIterator> + : public StateIterator>> { + public: + explicit StateIterator(const InvertFst &fst) + : StateIterator>>(fst) {} +}; + +// Specialization for InvertFst. +template +class ArcIterator> + : public ArcIterator>> { + public: + using StateId = typename Arc::StateId; + + ArcIterator(const InvertFst &fst, StateId s) + : ArcIterator>>(fst, s) {} +}; + +// Useful alias when using StdArc. +using StdInvertFst = InvertFst; + +} // namespace fst + +#endif // FST_INVERT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/isomorphic.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/isomorphic.h new file mode 100644 index 0000000000..b100b0a61d --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/isomorphic.h @@ -0,0 +1,183 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Function to test two FSTs are isomorphic, i.e., they are equal up to a state +// and arc re-ordering. FSTs should be deterministic when viewed as +// unweighted automata. + +#ifndef FST_ISOMORPHIC_H_ +#define FST_ISOMORPHIC_H_ + +#include +#include +#include +#include + +#include + +#include + + +namespace fst { +namespace internal { + +// Orders weights for equality checking. +template ::value>::type * = nullptr> +bool WeightCompare(const Weight &w1, const Weight &w2, float delta, + bool *error) { + return NaturalLess()(w1, w2); +} + +template ::value>::type * = nullptr> +bool WeightCompare(const Weight &w1, const Weight &w2, float delta, + bool *error) { + // No natural order; use hash. + const auto q1 = w1.Quantize(delta); + const auto q2 = w2.Quantize(delta); + auto n1 = q1.Hash(); + auto n2 = q2.Hash(); + // Hash not unique; very unlikely to happen. + if (n1 == n2 && q1 != q2) { + VLOG(1) << "Isomorphic: Weight hash collision"; + *error = true; + } + return n1 < n2; +} + +template +class Isomorphism { + using StateId = typename Arc::StateId; + + public: + Isomorphism(const Fst &fst1, const Fst &fst2, float delta) + : fst1_(fst1.Copy()), + fst2_(fst2.Copy()), + delta_(delta), + error_(false), + comp_(delta, &error_) {} + + // Checks if input FSTs are isomorphic. + bool IsIsomorphic() { + if (fst1_->Start() == kNoStateId && fst2_->Start() == kNoStateId) { + return true; + } + if (fst1_->Start() == kNoStateId || fst2_->Start() == kNoStateId) { + return false; + } + PairState(fst1_->Start(), fst2_->Start()); + while (!queue_.empty()) { + const auto &pr = queue_.front(); + if (!IsIsomorphicState(pr.first, pr.second)) return false; + queue_.pop_front(); + } + return true; + } + + bool Error() const { return error_; } + + private: + // Orders arcs for equality checking. + class ArcCompare { + public: + ArcCompare(float delta, bool *error) : delta_(delta), error_(error) {} + + bool operator()(const Arc &arc1, const Arc &arc2) const { + if (arc1.ilabel < arc2.ilabel) return true; + if (arc1.ilabel > arc2.ilabel) return false; + if (arc1.olabel < arc2.olabel) return true; + if (arc1.olabel > arc2.olabel) return false; + return WeightCompare(arc1.weight, arc2.weight, delta_, error_); + } + + private: + float delta_; + bool *error_; + }; + + // Maintains state correspondences and queue. + bool PairState(StateId s1, StateId s2) { + if (state_pairs_.size() <= s1) state_pairs_.resize(s1 + 1, kNoStateId); + if (state_pairs_[s1] == s2) { + return true; // already seen this pair + } else if (state_pairs_[s1] != kNoStateId) { + return false; // s1 already paired with another s2 + } + state_pairs_[s1] = s2; + queue_.push_back(std::make_pair(s1, s2)); + return true; + } + + // Checks if state pair is isomorphic + bool IsIsomorphicState(StateId s1, StateId s2); + + std::unique_ptr> fst1_; + std::unique_ptr> fst2_; + float delta_; // Weight equality delta. + std::vector arcs1_; // For sorting arcs on FST1. + std::vector arcs2_; // For sorting arcs on FST2. + std::vector state_pairs_; // Maintains state correspondences. + std::list> queue_; // Queue of state pairs. + bool error_; // Error flag. + ArcCompare comp_; +}; + +template +bool Isomorphism::IsIsomorphicState(StateId s1, StateId s2) { + if (!ApproxEqual(fst1_->Final(s1), fst2_->Final(s2), delta_)) return false; + auto narcs1 = fst1_->NumArcs(s1); + auto narcs2 = fst2_->NumArcs(s2); + if (narcs1 != narcs2) return false; + ArcIterator> aiter1(*fst1_, s1); + ArcIterator> aiter2(*fst2_, s2); + arcs1_.clear(); + arcs1_.reserve(narcs1); + arcs2_.clear(); + arcs2_.reserve(narcs2); + for (; !aiter1.Done(); aiter1.Next(), aiter2.Next()) { + arcs1_.push_back(aiter1.Value()); + arcs2_.push_back(aiter2.Value()); + } + std::sort(arcs1_.begin(), arcs1_.end(), comp_); + std::sort(arcs2_.begin(), arcs2_.end(), comp_); + for (size_t i = 0; i < arcs1_.size(); ++i) { + const auto &arc1 = arcs1_[i]; + const auto &arc2 = arcs2_[i]; + if (arc1.ilabel != arc2.ilabel) return false; + if (arc1.olabel != arc2.olabel) return false; + if (!ApproxEqual(arc1.weight, arc2.weight, delta_)) return false; + if (!PairState(arc1.nextstate, arc2.nextstate)) return false; + if (i > 0) { // Checks for non-determinism. + const auto &arc0 = arcs1_[i - 1]; + if (arc1.ilabel == arc0.ilabel && arc1.olabel == arc0.olabel && + ApproxEqual(arc1.weight, arc0.weight, delta_)) { + VLOG(1) << "Isomorphic: Non-determinism as an unweighted automaton"; + error_ = true; + return false; + } + } + } + return true; +} + +} // namespace internal + +// Tests if two FSTs have the same states and arcs up to a reordering. +// Inputs should be non-deterministic when viewed as unweighted automata. +template +bool Isomorphic(const Fst &fst1, const Fst &fst2, + float delta = kDelta) { + internal::Isomorphism iso(fst1, fst2, delta); + bool result = iso.IsIsomorphic(); + if (iso.Error()) { + FSTERROR() << "Isomorphic: Cannot determine if inputs are isomorphic"; + return false; + } else { + return result; + } +} + +} // namespace fst + +#endif // FST_ISOMORPHIC_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/label-reachable.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/label-reachable.h new file mode 100644 index 0000000000..fca6cc2717 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/label-reachable.h @@ -0,0 +1,511 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Class to determine if a non-epsilon label can be read as the first +// non-epsilon symbol along some path from a given state. + +#ifndef FST_LABEL_REACHABLE_H_ +#define FST_LABEL_REACHABLE_H_ + +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include + + +namespace fst { + +// Stores shareable data for label reachable class copies. +template +class LabelReachableData { + public: + using LabelIntervalSet = IntervalSet *fst, C *mapper) { + ArcMap(fst, mapper); +} + +template +void Map(MutableFst *fst, C mapper) { + ArcMap(fst, mapper); +} + +template +void Map(const Fst &ifst, MutableFst *ofst, C *mapper) { + ArcMap(ifst, ofst, mapper); +} + +template +void Map(const Fst &ifst, MutableFst *ofst, C mapper) { + ArcMap(ifst, ofst, mapper); +} + +using MapFstOptions = ArcMapFstOptions; + +template +class MapFst : public ArcMapFst { + public: + using FromArc = A; + using ToArc = B; + + using StateId = typename ToArc::StateId; + using Weight = typename ToArc::Weight; + + using State = CacheState; + + MapFst(const Fst &fst, const C &mapper, const MapFstOptions &opts) + : ArcMapFst(fst, mapper, opts) {} + + MapFst(const Fst &fst, C *mapper, const MapFstOptions &opts) + : ArcMapFst(fst, mapper, opts) {} + + MapFst(const Fst &fst, const C &mapper) + : ArcMapFst(fst, mapper) {} + + MapFst(const Fst &fst, C *mapper) : ArcMapFst(fst, mapper) {} + + // See Fst<>::Copy() for doc. + MapFst(const MapFst &fst, bool safe = false) + : ArcMapFst(fst, safe) {} + + // Get a copy of this MapFst. See Fst<>::Copy() for further doc. + MapFst *Copy(bool safe = false) const override { + return new MapFst(*this, safe); + } +}; + +// Specialization for MapFst. +template +class StateIterator> + : public StateIterator> { + public: + explicit StateIterator(const ArcMapFst &fst) + : StateIterator>(fst) {} +}; + +// Specialization for MapFst. +template +class ArcIterator> : public ArcIterator> { + public: + ArcIterator(const ArcMapFst &fst, typename A::StateId s) + : ArcIterator>(fst, s) {} +}; + +// For backwards compatibility only; use IdentityArcMapper otherwise. +template +struct IdentityMapper { + using FromArc = A; + using ToArc = A; + + ToArc operator()(const FromArc &arc) const { return arc; } + + constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; } + + constexpr MapSymbolsAction InputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + constexpr MapSymbolsAction OutputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + uint64 Properties(uint64 props) const { return props; } +}; + +} // namespace fst + +#endif // FST_MAP_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/mapped-file.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/mapped-file.h new file mode 100644 index 0000000000..0471ff80ed --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/mapped-file.h @@ -0,0 +1,75 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_MAPPED_FILE_H_ +#define FST_MAPPED_FILE_H_ + +#include +#include +#include + +#include +#include + +namespace fst { + +// A memory region is a simple abstraction for allocated memory or data from +// memory-mapped files. If mmap is null, then data represents an owned region +// of size bytes. Otherwise, mmap and size refer to the mapping and data is a +// casted pointer to a region contained within [mmap, mmap + size). If size is +// 0, then mmap and data refer to a block of memory managed externally by some +// other allocator. The offset is used when allocating memory to providing +// padding for alignment. +struct MemoryRegion { + void *data; + void *mmap; + size_t size; + int offset; +}; + +class MappedFile { + public: + ~MappedFile(); + + void *mutable_data() const { return region_.data; } + + const void *data() const { return region_.data; } + + // Returns a MappedFile object that contains the contents of the input stream + // strm starting from the current file position with size bytes. The memorymap + // bool is advisory, and Map will default to allocating and reading. The + // source argument needs to contain the filename that was used to open the + // input stream. + static MappedFile *Map(std::istream *istrm, bool memorymap, + const string &source, size_t size); + + // Creates a MappedFile object with a new[]'ed block of memory of size. The + // align argument can be used to specify a desired block alignment. + // This is RECOMMENDED FOR INTERNAL USE ONLY as it may change in future + // releases. + static MappedFile *Allocate(size_t size, int align = kArchAlignment); + + // Creates a MappedFile object pointing to a borrowed reference to data. This + // block of memory is not owned by the MappedFile object and will not be + // freed. This is RECOMMENDED FOR INTERNAL USE ONLY, may change in future + // releases. + static MappedFile *Borrow(void *data); + + // Alignment required for mapping structures in bytes. Regions of memory that + // are not aligned upon a 128-bit boundary are read from the file instead. + // This is consistent with the alignment boundary set in ConstFst and + // CompactFst. + static constexpr int kArchAlignment = 16; + + static constexpr size_t kMaxReadChunk = 256 * 1024 * 1024; // 256 MB. + + private: + explicit MappedFile(const MemoryRegion ®ion); + + MemoryRegion region_; + MappedFile(const MappedFile &) = delete; + MappedFile &operator=(const MappedFile &) = delete; +}; +} // namespace fst + +#endif // FST_MAPPED_FILE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/matcher-fst.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/matcher-fst.h new file mode 100644 index 0000000000..61e95820b9 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/matcher-fst.h @@ -0,0 +1,347 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Class to add a matcher to an FST. + +#ifndef FST_MATCHER_FST_H_ +#define FST_MATCHER_FST_H_ + +#include +#include + +#include +#include +#include + + +namespace fst { + +// Writeable matchers have the same interface as Matchers (as defined in +// matcher.h) along with the following additional methods: +// +// template +// class Matcher { +// public: +// using FST = F; +// ... +// using MatcherData = ...; // Initialization data. +// +// // Constructor with additional argument for external initialization data; +// // matcher increments its reference count on construction and decrements +// // the reference count, and deletes once the reference count has reached +// // zero. +// Matcher(const FST &fst, MatchType type, MatcherData *data); +// +// // Returns pointer to initialization data that can be passed to a Matcher +// // constructor. +// MatcherData *GetData() const; +// }; + +// The matcher initialization data class must also provide the following +// interface: +// +// class MatcherData { +// public: +// // Required copy constructor. +// MatcherData(const MatcherData &); +// +// // Required I/O methods. +// static MatcherData *Read(std::istream &istrm, const FstReadOptions &opts); +// bool Write(std::ostream &ostrm, const FstWriteOptions &opts) const; +// }; + +// Trivial (no-op) MatcherFst initializer functor. +template +class NullMatcherFstInit { + public: + using MatcherData = typename M::MatcherData; + using Data = AddOnPair; + using Impl = internal::AddOnImpl; + + explicit NullMatcherFstInit(std::shared_ptr *) {} +}; + +// Class adding a matcher to an FST type. Creates a new FST whose name is given +// by N. An optional functor Init can be used to initialize the FST. The Data +// template parameter allows the user to select the type of the add-on. +template < + class F, class M, const char *Name, class Init = NullMatcherFstInit, + class Data = AddOnPair> +class MatcherFst : public ImplToExpandedFst> { + public: + using FST = F; + using Arc = typename FST::Arc; + using StateId = typename Arc::StateId; + + using FstMatcher = M; + using MatcherData = typename FstMatcher::MatcherData; + + using Impl = internal::AddOnImpl; + using D = Data; + + friend class StateIterator>; + friend class ArcIterator>; + + MatcherFst() : ImplToExpandedFst(std::make_shared(FST(), Name)) {} + + explicit MatcherFst(const FST &fst, std::shared_ptr data = nullptr) + : ImplToExpandedFst(data ? CreateImpl(fst, Name, data) + : CreateDataAndImpl(fst, Name)) {} + + explicit MatcherFst(const Fst &fst) + : ImplToExpandedFst(CreateDataAndImpl(fst, Name)) {} + + // See Fst<>::Copy() for doc. + MatcherFst(const MatcherFst &fst, + bool safe = false) + : ImplToExpandedFst(fst, safe) {} + + // Get a copy of this MatcherFst. See Fst<>::Copy() for further doc. + MatcherFst *Copy( + bool safe = false) const override { + return new MatcherFst(*this, safe); + } + + // Read a MatcherFst from an input stream; return nullptr on error + static MatcherFst *Read( + std::istream &strm, const FstReadOptions &opts) { + auto *impl = Impl::Read(strm, opts); + return impl ? new MatcherFst( + std::shared_ptr(impl)) + : nullptr; + } + + // Read a MatcherFst from a file; return nullptr on error + // Empty filename reads from standard input + static MatcherFst *Read( + const string &filename) { + auto *impl = ImplToExpandedFst::Read(filename); + return impl ? new MatcherFst( + std::shared_ptr(impl)) + : nullptr; + } + + bool Write(std::ostream &strm, const FstWriteOptions &opts) const override { + return GetImpl()->Write(strm, opts); + } + + bool Write(const string &filename) const override { + return Fst::WriteFile(filename); + } + + void InitStateIterator(StateIteratorData *data) const override { + return GetImpl()->InitStateIterator(data); + } + + void InitArcIterator(StateId s, ArcIteratorData *data) const override { + return GetImpl()->InitArcIterator(s, data); + } + + FstMatcher *InitMatcher(MatchType match_type) const override { + return new FstMatcher(&GetFst(), match_type, GetSharedData(match_type)); + } + + const FST &GetFst() const { return GetImpl()->GetFst(); } + + const Data *GetAddOn() const { return GetImpl()->GetAddOn(); } + + std::shared_ptr GetSharedAddOn() const { + return GetImpl()->GetSharedAddOn(); + } + + const MatcherData *GetData(MatchType match_type) const { + const auto *data = GetAddOn(); + return match_type == MATCH_INPUT ? data->First() : data->Second(); + } + + std::shared_ptr GetSharedData(MatchType match_type) const { + const auto *data = GetAddOn(); + return match_type == MATCH_INPUT ? data->SharedFirst() + : data->SharedSecond(); + } + + protected: + using ImplToFst>::GetImpl; + + static std::shared_ptr CreateDataAndImpl(const FST &fst, + const string &name) { + FstMatcher imatcher(fst, MATCH_INPUT); + FstMatcher omatcher(fst, MATCH_OUTPUT); + return CreateImpl(fst, name, + std::make_shared(imatcher.GetSharedData(), + omatcher.GetSharedData())); + } + + static std::shared_ptr CreateDataAndImpl(const Fst &fst, + const string &name) { + FST result(fst); + return CreateDataAndImpl(result, name); + } + + static std::shared_ptr CreateImpl(const FST &fst, const string &name, + std::shared_ptr data) { + auto impl = std::make_shared(fst, name); + impl->SetAddOn(data); + Init init(&impl); + return impl; + } + + explicit MatcherFst(std::shared_ptr impl) + : ImplToExpandedFst(impl) {} + + private: + MatcherFst &operator=(const MatcherFst &) = delete; +}; + +// Specialization for MatcherFst. +template +class StateIterator> + : public StateIterator { + public: + explicit StateIterator(const MatcherFst &fst) + : StateIterator(fst.GetImpl()->GetFst()) {} +}; + +// Specialization for MatcherFst. +template +class ArcIterator> : public ArcIterator { + public: + using StateId = typename FST::Arc::StateId; + + ArcIterator(const MatcherFst &fst, + typename FST::Arc::StateId s) + : ArcIterator(fst.GetImpl()->GetFst(), s) {} +}; + +// Specialization for MatcherFst. +template +class Matcher> { + public: + using FST = MatcherFst; + using Arc = typename F::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + + Matcher(const FST &fst, MatchType match_type) + : matcher_(fst.InitMatcher(match_type)) {} + + Matcher(const Matcher &matcher) : matcher_(matcher.matcher_->Copy()) {} + + Matcher *Copy() const { return new Matcher(*this); } + + MatchType Type(bool test) const { return matcher_->Type(test); } + + void SetState(StateId s) { matcher_->SetState(s); } + + bool Find(Label label) { return matcher_->Find(label); } + + bool Done() const { return matcher_->Done(); } + + const Arc &Value() const { return matcher_->Value(); } + + void Next() { matcher_->Next(); } + + uint64 Properties(uint64 props) const { return matcher_->Properties(props); } + + uint32 Flags() const { return matcher_->Flags(); } + + private: + std::unique_ptr matcher_; +}; + +// Specialization for MatcherFst. +template +class LookAheadMatcher> { + public: + using FST = MatcherFst; + using Arc = typename F::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + LookAheadMatcher(const FST &fst, MatchType match_type) + : matcher_(fst.InitMatcher(match_type)) {} + + LookAheadMatcher(const LookAheadMatcher &matcher, bool safe = false) + : matcher_(matcher.matcher_->Copy(safe)) {} + + // General matcher methods. + LookAheadMatcher *Copy(bool safe = false) const { + return new LookAheadMatcher(*this, safe); + } + + MatchType Type(bool test) const { return matcher_->Type(test); } + + void SetState(StateId s) { matcher_->SetState(s); } + + bool Find(Label label) { return matcher_->Find(label); } + + bool Done() const { return matcher_->Done(); } + + const Arc &Value() const { return matcher_->Value(); } + + void Next() { matcher_->Next(); } + + const FST &GetFst() const { return matcher_->GetFst(); } + + uint64 Properties(uint64 props) const { return matcher_->Properties(props); } + + uint32 Flags() const { return matcher_->Flags(); } + + bool LookAheadLabel(Label label) const { + return matcher_->LookAheadLabel(label); + } + + bool LookAheadFst(const Fst &fst, StateId s) { + return matcher_->LookAheadFst(fst, s); + } + + Weight LookAheadWeight() const { return matcher_->LookAheadWeight(); } + + bool LookAheadPrefix(Arc *arc) const { + return matcher_->LookAheadPrefix(arc); + } + + void InitLookAheadFst(const Fst &fst, bool copy = false) { + matcher_->InitLookAheadFst(fst, copy); + } + + private: + std::unique_ptr matcher_; +}; + +// Useful aliases when using StdArc. + +extern const char arc_lookahead_fst_type[]; + +using StdArcLookAheadFst = + MatcherFst, + ArcLookAheadMatcher>>, + arc_lookahead_fst_type>; + +extern const char ilabel_lookahead_fst_type[]; +extern const char olabel_lookahead_fst_type[]; + +constexpr auto ilabel_lookahead_flags = + kInputLookAheadMatcher | kLookAheadWeight | kLookAheadPrefix | + kLookAheadEpsilons | kLookAheadNonEpsilonPrefix; + +constexpr auto olabel_lookahead_flags = + kOutputLookAheadMatcher | kLookAheadWeight | kLookAheadPrefix | + kLookAheadEpsilons | kLookAheadNonEpsilonPrefix; + +using StdILabelLookAheadFst = MatcherFst< + ConstFst, + LabelLookAheadMatcher>, + ilabel_lookahead_flags, FastLogAccumulator>, + ilabel_lookahead_fst_type, LabelLookAheadRelabeler>; + +using StdOLabelLookAheadFst = MatcherFst< + ConstFst, + LabelLookAheadMatcher>, + olabel_lookahead_flags, FastLogAccumulator>, + olabel_lookahead_fst_type, LabelLookAheadRelabeler>; + +} // namespace fst + +#endif // FST_MATCHER_FST_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/matcher.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/matcher.h new file mode 100644 index 0000000000..cbda5d8b3c --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/matcher.h @@ -0,0 +1,1559 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Classes to allow matching labels leaving FST states. + +#ifndef FST_MATCHER_H_ +#define FST_MATCHER_H_ + +#include +#include +#include + +#include + +#include // for all internal FST accessors. + + +namespace fst { + +// Matchers find and iterate through requested labels at FST states. In the +// simplest form, these are just some associative map or search keyed on labels. +// More generally, they may implement matching special labels that represent +// sets of labels such as sigma (all), rho (rest), or phi (fail). The Matcher +// interface is: +// +// template +// class Matcher { +// public: +// using FST = F; +// using Arc = typename FST::Arc; +// using Label = typename Arc::Label; +// using StateId = typename Arc::StateId; +// using Weight = typename Arc::Weight; +// +// // Required constructors. Note: +// // -- the constructors that copy the FST arg are useful for +// // letting the matcher manage the FST through copies +// // (esp with 'safe' copies); e.g. ComposeFst depends on this. +// // -- the constructor that does not copy is useful when the +// // the FST is mutated during the lifetime of the matcher +// // (o.w. the matcher would have its own unmutated deep copy). +// +// // This makes a copy of the FST. +// Matcher(const FST &fst, MatchType type); +// // This doesn't copy the FST. +// Matcher(const FST *fst, MatchType type); +// // This makes a copy of the FST. +// // See Copy() below. +// Matcher(const Matcher &matcher, bool safe = false); +// +// // If safe = true, the copy is thread-safe. See Fst<>::Copy() for +// // further doc. +// Matcher *Copy(bool safe = false) const override; +// +// // Returns the match type that can be provided (depending on compatibility +// of the input FST). It is either the requested match type, MATCH_NONE, or +// MATCH_UNKNOWN. If test is false, a costly testing is avoided, but +// MATCH_UNKNOWN may be returned. If test is true, a definite answer is +// returned, but may involve more costly computation (e.g., visiting the FST). +// MatchType Type(bool test) const override; +// +// // Specifies the current state. +// void SetState(StateId s) final; +// +// // Finds matches to a label at the current state, returning true if a match +// // found. kNoLabel matches any non-consuming transitions, e.g., epsilon +// // transitions, which do not require a matching symbol. +// bool Find(Label label) final; +// +// // Iterator methods. Note that initially and after SetState() these have +// undefined behavior until Find() is called. +// +// bool Done() const final; +// +// const Arc &Value() const final; +// +// void Next() final; +// +// // Returns final weight of a state. +// Weight Final(StateId) const final; +// +// // Indicates preference for being the side used for matching in +// // composition. If the value is kRequirePriority, then it is +// // mandatory that it be used. Calling this method without passing the +// // current state of the matcher invalidates the state of the matcher. +// ssize_t Priority(StateId s) final; +// +// // This specifies the known FST properties as viewed from this matcher. It +// // takes as argument the input FST's known properties. +// uint64 Properties(uint64 props) const override; +// +// // Returns matcher flags. +// uint32 Flags() const override; +// +// // Returns matcher FST. +// const FST &GetFst() const override; +// }; + +// Basic matcher flags. + +// Matcher needs to be used as the matching side in composition for +// at least one state (has kRequirePriority). +constexpr uint32 kRequireMatch = 0x00000001; + +// Flags used for basic matchers (see also lookahead.h). +constexpr uint32 kMatcherFlags = kRequireMatch; + +// Matcher priority that is mandatory. +constexpr ssize_t kRequirePriority = -1; + +// Matcher interface, templated on the Arc definition; used for matcher +// specializations that are returned by the InitMatcher FST method. +template +class MatcherBase { + public: + using Arc = A; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + virtual ~MatcherBase() {} + + // Virtual interface. + + virtual MatcherBase *Copy(bool safe = false) const = 0; + virtual MatchType Type(bool) const = 0; + virtual void SetState(StateId) = 0; + virtual bool Find(Label) = 0; + virtual bool Done() const = 0; + virtual const Arc &Value() const = 0; + virtual void Next() = 0; + virtual const Fst &GetFst() const = 0; + virtual uint64 Properties(uint64) const = 0; + + // Trivial implementations that can be used by derived classes. Full + // devirtualization is expected for any derived class marked final. + virtual uint32 Flags() const { return 0; } + + virtual Weight Final(StateId s) const { return internal::Final(GetFst(), s); } + + virtual ssize_t Priority(StateId s) { return internal::NumArcs(GetFst(), s); } +}; + +// A matcher that expects sorted labels on the side to be matched. +// If match_type == MATCH_INPUT, epsilons match the implicit self-loop +// Arc(kNoLabel, 0, Weight::One(), current_state) as well as any +// actual epsilon transitions. If match_type == MATCH_OUTPUT, then +// Arc(0, kNoLabel, Weight::One(), current_state) is instead matched. +template +class SortedMatcher : public MatcherBase { + public: + using FST = F; + using Arc = typename FST::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using MatcherBase::Flags; + using MatcherBase::Properties; + + // Labels >= binary_label will be searched for by binary search; + // o.w. linear search is used. + // This makes a copy of the FST. + SortedMatcher(const FST &fst, MatchType match_type, Label binary_label = 1) + : SortedMatcher(fst.Copy(), match_type, binary_label) { + owned_fst_.reset(&fst_); + } + + // Labels >= binary_label will be searched for by binary search; + // o.w. linear search is used. + // This doesn't copy the FST. + SortedMatcher(const FST *fst, MatchType match_type, Label binary_label = 1) + : fst_(*fst), + state_(kNoStateId), + aiter_(nullptr), + match_type_(match_type), + binary_label_(binary_label), + match_label_(kNoLabel), + narcs_(0), + loop_(kNoLabel, 0, Weight::One(), kNoStateId), + error_(false), + aiter_pool_(1) { + switch (match_type_) { + case MATCH_INPUT: + case MATCH_NONE: + break; + case MATCH_OUTPUT: + std::swap(loop_.ilabel, loop_.olabel); + break; + default: + FSTERROR() << "SortedMatcher: Bad match type"; + match_type_ = MATCH_NONE; + error_ = true; + } + } + + // This makes a copy of the FST. + SortedMatcher(const SortedMatcher &matcher, bool safe = false) + : owned_fst_(matcher.fst_.Copy(safe)), + fst_(*owned_fst_), + state_(kNoStateId), + aiter_(nullptr), + match_type_(matcher.match_type_), + binary_label_(matcher.binary_label_), + match_label_(kNoLabel), + narcs_(0), + loop_(matcher.loop_), + error_(matcher.error_), + aiter_pool_(1) {} + + ~SortedMatcher() override { Destroy(aiter_, &aiter_pool_); } + + SortedMatcher *Copy(bool safe = false) const override { + return new SortedMatcher(*this, safe); + } + + MatchType Type(bool test) const override { + if (match_type_ == MATCH_NONE) return match_type_; + const auto true_prop = + match_type_ == MATCH_INPUT ? kILabelSorted : kOLabelSorted; + const auto false_prop = + match_type_ == MATCH_INPUT ? kNotILabelSorted : kNotOLabelSorted; + const auto props = fst_.Properties(true_prop | false_prop, test); + if (props & true_prop) { + return match_type_; + } else if (props & false_prop) { + return MATCH_NONE; + } else { + return MATCH_UNKNOWN; + } + } + + void SetState(StateId s) final { + if (state_ == s) return; + state_ = s; + if (match_type_ == MATCH_NONE) { + FSTERROR() << "SortedMatcher: Bad match type"; + error_ = true; + } + Destroy(aiter_, &aiter_pool_); + aiter_ = new (&aiter_pool_) ArcIterator(fst_, s); + aiter_->SetFlags(kArcNoCache, kArcNoCache); + narcs_ = internal::NumArcs(fst_, s); + loop_.nextstate = s; + } + + bool Find(Label match_label) final { + exact_match_ = true; + if (error_) { + current_loop_ = false; + match_label_ = kNoLabel; + return false; + } + current_loop_ = match_label == 0; + match_label_ = match_label == kNoLabel ? 0 : match_label; + if (Search()) { + return true; + } else { + return current_loop_; + } + } + + // Positions matcher to the first position where inserting match_label would + // maintain the sort order. + void LowerBound(Label label) { + exact_match_ = false; + current_loop_ = false; + if (error_) { + match_label_ = kNoLabel; + return; + } + match_label_ = label; + Search(); + } + + // After Find(), returns false if no more exact matches. + // After LowerBound(), returns false if no more arcs. + bool Done() const final { + if (current_loop_) return false; + if (aiter_->Done()) return true; + if (!exact_match_) return false; + aiter_->SetFlags(match_type_ == MATCH_INPUT ? + kArcILabelValue : kArcOLabelValue, + kArcValueFlags); + return GetLabel() != match_label_; + } + + const Arc &Value() const final { + if (current_loop_) return loop_; + aiter_->SetFlags(kArcValueFlags, kArcValueFlags); + return aiter_->Value(); + } + + void Next() final { + if (current_loop_) { + current_loop_ = false; + } else { + aiter_->Next(); + } + } + + Weight Final(StateId s) const final { + return MatcherBase::Final(s); + } + + ssize_t Priority(StateId s) final { + return MatcherBase::Priority(s); + } + + const FST &GetFst() const override { return fst_; } + + uint64 Properties(uint64 inprops) const override { + return inprops | (error_ ? kError : 0); + } + + size_t Position() const { return aiter_ ? aiter_->Position() : 0; } + + private: + Label GetLabel() const { + const auto &arc = aiter_->Value(); + return match_type_ == MATCH_INPUT ? arc.ilabel : arc.olabel; + } + + bool BinarySearch(); + bool LinearSearch(); + bool Search(); + + std::unique_ptr owned_fst_; // FST ptr if owned. + const FST &fst_; // FST for matching. + StateId state_; // Matcher state. + ArcIterator *aiter_; // Iterator for current state. + MatchType match_type_; // Type of match to perform. + Label binary_label_; // Least label for binary search. + Label match_label_; // Current label to be matched. + size_t narcs_; // Current state arc count. + Arc loop_; // For non-consuming symbols. + bool current_loop_; // Current arc is the implicit loop. + bool exact_match_; // Exact match or lower bound? + bool error_; // Error encountered? + MemoryPool> aiter_pool_; // Pool of arc iterators. +}; + +// Returns true iff match to match_label_. The arc iterator is positioned at the +// lower bound, that is, the first element greater than or equal to +// match_label_, or the end if all elements are less than match_label_. +template +inline bool SortedMatcher::BinarySearch() { + size_t low = 0; + size_t high = narcs_; + while (low < high) { + const size_t mid = low + (high - low) / 2; + aiter_->Seek(mid); + if (GetLabel() < match_label_) { + low = mid + 1; + } else { + high = mid; + } + } + + aiter_->Seek(low); + return low < narcs_ && GetLabel() == match_label_; +} + +// Returns true iff match to match_label_, positioning arc iterator at lower +// bound. +template +inline bool SortedMatcher::LinearSearch() { + for (aiter_->Reset(); !aiter_->Done(); aiter_->Next()) { + const auto label = GetLabel(); + if (label == match_label_) return true; + if (label > match_label_) break; + } + return false; +} + +// Returns true iff match to match_label_, positioning arc iterator at lower +// bound. +template +inline bool SortedMatcher::Search() { + aiter_->SetFlags(match_type_ == MATCH_INPUT ? + kArcILabelValue : kArcOLabelValue, + kArcValueFlags); + if (match_label_ >= binary_label_) { + return BinarySearch(); + } else { + return LinearSearch(); + } +} + +// A matcher that stores labels in a per-state hash table populated upon the +// first visit to that state. Sorting is not required. Treatment of +// epsilons are the same as with SortedMatcher. +template +class HashMatcher : public MatcherBase { + public: + using FST = F; + using Arc = typename FST::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using MatcherBase::Flags; + using MatcherBase::Final; + using MatcherBase::Priority; + + // This makes a copy of the FST. + HashMatcher(const FST &fst, MatchType match_type) + : HashMatcher(fst.Copy(), match_type) { + owned_fst_.reset(&fst_); + } + + // This doesn't copy the FST. + HashMatcher(const FST *fst, MatchType match_type) + : fst_(*fst), + state_(kNoStateId), + match_type_(match_type), + loop_(kNoLabel, 0, Weight::One(), kNoStateId), + error_(false) { + switch (match_type_) { + case MATCH_INPUT: + case MATCH_NONE: + break; + case MATCH_OUTPUT: + std::swap(loop_.ilabel, loop_.olabel); + break; + default: + FSTERROR() << "HashMatcher: Bad match type"; + match_type_ = MATCH_NONE; + error_ = true; + } + } + + // This makes a copy of the FST. + HashMatcher(const HashMatcher &matcher, bool safe = false) + : owned_fst_(matcher.fst_.Copy(safe)), + fst_(*owned_fst_), + state_(kNoStateId), + match_type_(matcher.match_type_), + loop_(matcher.loop_), + error_(matcher.error_) {} + + HashMatcher *Copy(bool safe = false) const override { + return new HashMatcher(*this, safe); + } + + // The argument is ignored as there are no relevant properties to test. + MatchType Type(bool test) const override { return match_type_; } + + void SetState(StateId s) final; + + bool Find(Label label) final { + current_loop_ = label == 0; + if (label == 0) { + Search(label); + return true; + } + if (label == kNoLabel) label = 0; + return Search(label); + } + + bool Done() const final { + if (current_loop_) return false; + return label_it_ == label_end_; + } + + const Arc &Value() const final { + if (current_loop_) return loop_; + aiter_->Seek(label_it_->second); + return aiter_->Value(); + } + + void Next() final { + if (current_loop_) { + current_loop_ = false; + } else { + ++label_it_; + } + } + + const FST &GetFst() const override { return fst_; } + + uint64 Properties(uint64 inprops) const override { + return inprops | (error_ ? kError : 0); + } + + private: + Label GetLabel() const { + const auto &arc = aiter_->Value(); + return match_type_ == MATCH_INPUT ? arc.ilabel : arc.olabel; + } + + bool Search(Label match_label); + + using LabelTable = std::unordered_multimap; + using StateTable = std::unordered_map; + + std::unique_ptr owned_fst_; // ptr to FST if owned. + const FST &fst_; // FST for matching. + StateId state_; // Matcher state. + MatchType match_type_; + Arc loop_; // The implicit loop itself. + bool current_loop_; // Is the current arc the implicit loop? + bool error_; // Error encountered? + std::unique_ptr> aiter_; + StateTable state_table_; // Table from states to label table. + LabelTable *label_table_; // Pointer to current state's label table. + typename LabelTable::iterator label_it_; // Position for label. + typename LabelTable::iterator label_end_; // Position for last label + 1. +}; + +template +void HashMatcher::SetState(typename FST::Arc::StateId s) { + if (state_ == s) return; + // Resets everything for the state. + state_ = s; + loop_.nextstate = state_; + aiter_.reset(new ArcIterator(fst_, state_)); + if (match_type_ == MATCH_NONE) { + FSTERROR() << "HashMatcher: Bad match type"; + error_ = true; + } + // Attempts to insert a new label table; if it already exists, + // no additional work is done and we simply return. + auto it_and_success = state_table_.emplace(state_, LabelTable()); + if (!it_and_success.second) return; + // Otherwise, populate this new table. + // Sets instance's pointer to the label table for this state. + label_table_ = &(it_and_success.first->second); + // Populates the label table. + label_table_->reserve(internal::NumArcs(fst_, state_)); + const auto aiter_flags = + (match_type_ == MATCH_INPUT ? kArcILabelValue : kArcOLabelValue) | + kArcNoCache; + aiter_->SetFlags(aiter_flags, kArcFlags); + for (; !aiter_->Done(); aiter_->Next()) { + label_table_->emplace(GetLabel(), aiter_->Position()); + } + aiter_->SetFlags(kArcValueFlags, kArcValueFlags); +} + +template +inline bool HashMatcher::Search(typename FST::Arc::Label match_label) { + auto range = label_table_->equal_range(match_label); + if (range.first == range.second) return false; + label_it_ = range.first; + label_end_ = range.second; + aiter_->Seek(label_it_->second); + return true; +} + +// Specifies whether we rewrite both the input and output sides during matching. +enum MatcherRewriteMode { + MATCHER_REWRITE_AUTO = 0, // Rewrites both sides iff acceptor. + MATCHER_REWRITE_ALWAYS, + MATCHER_REWRITE_NEVER +}; + +// For any requested label that doesn't match at a state, this matcher +// considers the *unique* transition that matches the label 'phi_label' +// (phi = 'fail'), and recursively looks for a match at its +// destination. When 'phi_loop' is true, if no match is found but a +// phi self-loop is found, then the phi transition found is returned +// with the phi_label rewritten as the requested label (both sides if +// an acceptor, or if 'rewrite_both' is true and both input and output +// labels of the found transition are 'phi_label'). If 'phi_label' is +// kNoLabel, this special matching is not done. PhiMatcher is +// templated itself on a matcher, which is used to perform the +// underlying matching. By default, the underlying matcher is +// constructed by PhiMatcher. The user can instead pass in this +// object; in that case, PhiMatcher takes its ownership. +// Phi non-determinism not supported. No non-consuming symbols other +// than epsilon supported with the underlying template argument matcher. +template +class PhiMatcher : public MatcherBase { + public: + using FST = typename M::FST; + using Arc = typename FST::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + // This makes a copy of the FST (w/o 'matcher' arg). + PhiMatcher(const FST &fst, MatchType match_type, Label phi_label = kNoLabel, + bool phi_loop = true, + MatcherRewriteMode rewrite_mode = MATCHER_REWRITE_AUTO, + M *matcher = nullptr) + : matcher_(matcher ? matcher : new M(fst, match_type)), + match_type_(match_type), + phi_label_(phi_label), + state_(kNoStateId), + phi_loop_(phi_loop), + error_(false) { + if (match_type == MATCH_BOTH) { + FSTERROR() << "PhiMatcher: Bad match type"; + match_type_ = MATCH_NONE; + error_ = true; + } + if (rewrite_mode == MATCHER_REWRITE_AUTO) { + rewrite_both_ = fst.Properties(kAcceptor, true); + } else if (rewrite_mode == MATCHER_REWRITE_ALWAYS) { + rewrite_both_ = true; + } else { + rewrite_both_ = false; + } + } + + // This doesn't copy the FST. + PhiMatcher(const FST *fst, MatchType match_type, Label phi_label = kNoLabel, + bool phi_loop = true, + MatcherRewriteMode rewrite_mode = MATCHER_REWRITE_AUTO, + M *matcher = nullptr) + : PhiMatcher(*fst, match_type, phi_label, phi_loop, rewrite_mode, + matcher ? matcher : new M(fst, match_type)) { } + + + // This makes a copy of the FST. + PhiMatcher(const PhiMatcher &matcher, bool safe = false) + : matcher_(new M(*matcher.matcher_, safe)), + match_type_(matcher.match_type_), + phi_label_(matcher.phi_label_), + rewrite_both_(matcher.rewrite_both_), + state_(kNoStateId), + phi_loop_(matcher.phi_loop_), + error_(matcher.error_) {} + + PhiMatcher *Copy(bool safe = false) const override { + return new PhiMatcher(*this, safe); + } + + MatchType Type(bool test) const override { return matcher_->Type(test); } + + void SetState(StateId s) final { + if (state_ == s) return; + matcher_->SetState(s); + state_ = s; + has_phi_ = phi_label_ != kNoLabel; + } + + bool Find(Label match_label) final; + + bool Done() const final { return matcher_->Done(); } + + const Arc &Value() const final { + if ((phi_match_ == kNoLabel) && (phi_weight_ == Weight::One())) { + return matcher_->Value(); + } else if (phi_match_ == 0) { // Virtual epsilon loop. + phi_arc_ = Arc(kNoLabel, 0, Weight::One(), state_); + if (match_type_ == MATCH_OUTPUT) { + std::swap(phi_arc_.ilabel, phi_arc_.olabel); + } + return phi_arc_; + } else { + phi_arc_ = matcher_->Value(); + phi_arc_.weight = Times(phi_weight_, phi_arc_.weight); + if (phi_match_ != kNoLabel) { // Phi loop match. + if (rewrite_both_) { + if (phi_arc_.ilabel == phi_label_) phi_arc_.ilabel = phi_match_; + if (phi_arc_.olabel == phi_label_) phi_arc_.olabel = phi_match_; + } else if (match_type_ == MATCH_INPUT) { + phi_arc_.ilabel = phi_match_; + } else { + phi_arc_.olabel = phi_match_; + } + } + return phi_arc_; + } + } + + void Next() final { matcher_->Next(); } + + Weight Final(StateId s) const final { + auto weight = matcher_->Final(s); + if (phi_label_ == kNoLabel || weight != Weight::Zero()) { + return weight; + } + weight = Weight::One(); + matcher_->SetState(s); + while (matcher_->Final(s) == Weight::Zero()) { + if (!matcher_->Find(phi_label_ == 0 ? -1 : phi_label_)) break; + weight = Times(weight, matcher_->Value().weight); + if (s == matcher_->Value().nextstate) { + return Weight::Zero(); // Does not follow phi self-loops. + } + s = matcher_->Value().nextstate; + matcher_->SetState(s); + } + weight = Times(weight, matcher_->Final(s)); + return weight; + } + + ssize_t Priority(StateId s) final { + if (phi_label_ != kNoLabel) { + matcher_->SetState(s); + const bool has_phi = matcher_->Find(phi_label_ == 0 ? -1 : phi_label_); + return has_phi ? kRequirePriority : matcher_->Priority(s); + } else { + return matcher_->Priority(s); + } + } + + const FST &GetFst() const override { return matcher_->GetFst(); } + + uint64 Properties(uint64 props) const override; + + uint32 Flags() const override { + if (phi_label_ == kNoLabel || match_type_ == MATCH_NONE) { + return matcher_->Flags(); + } + return matcher_->Flags() | kRequireMatch; + } + + Label PhiLabel() const { return phi_label_; } + + private: + mutable std::unique_ptr matcher_; + MatchType match_type_; // Type of match requested. + Label phi_label_; // Label that represents the phi transition. + bool rewrite_both_; // Rewrite both sides when both are phi_label_? + bool has_phi_; // Are there possibly phis at the current state? + Label phi_match_; // Current label that matches phi loop. + mutable Arc phi_arc_; // Arc to return. + StateId state_; // Matcher state. + Weight phi_weight_; // Product of the weights of phi transitions taken. + bool phi_loop_; // When true, phi self-loop are allowed and treated + // as rho (required for Aho-Corasick). + bool error_; // Error encountered? + + PhiMatcher &operator=(const PhiMatcher &) = delete; +}; + +template +inline bool PhiMatcher::Find(Label label) { + if (label == phi_label_ && phi_label_ != kNoLabel && phi_label_ != 0) { + FSTERROR() << "PhiMatcher::Find: bad label (phi): " << phi_label_; + error_ = true; + return false; + } + matcher_->SetState(state_); + phi_match_ = kNoLabel; + phi_weight_ = Weight::One(); + // If phi_label_ == 0, there are no more true epsilon arcs. + if (phi_label_ == 0) { + if (label == kNoLabel) { + return false; + } + if (label == 0) { // but a virtual epsilon loop needs to be returned. + if (!matcher_->Find(kNoLabel)) { + return matcher_->Find(0); + } else { + phi_match_ = 0; + return true; + } + } + } + if (!has_phi_ || label == 0 || label == kNoLabel) { + return matcher_->Find(label); + } + auto s = state_; + while (!matcher_->Find(label)) { + // Look for phi transition (if phi_label_ == 0, we need to look + // for -1 to avoid getting the virtual self-loop) + if (!matcher_->Find(phi_label_ == 0 ? -1 : phi_label_)) return false; + if (phi_loop_ && matcher_->Value().nextstate == s) { + phi_match_ = label; + return true; + } + phi_weight_ = Times(phi_weight_, matcher_->Value().weight); + s = matcher_->Value().nextstate; + matcher_->Next(); + if (!matcher_->Done()) { + FSTERROR() << "PhiMatcher: Phi non-determinism not supported"; + error_ = true; + } + matcher_->SetState(s); + } + return true; +} + +template +inline uint64 PhiMatcher::Properties(uint64 inprops) const { + auto outprops = matcher_->Properties(inprops); + if (error_) outprops |= kError; + if (match_type_ == MATCH_NONE) { + return outprops; + } else if (match_type_ == MATCH_INPUT) { + if (phi_label_ == 0) { + outprops &= ~kEpsilons | ~kIEpsilons | ~kOEpsilons; + outprops |= kNoEpsilons | kNoIEpsilons; + } + if (rewrite_both_) { + return outprops & + ~(kODeterministic | kNonODeterministic | kString | kILabelSorted | + kNotILabelSorted | kOLabelSorted | kNotOLabelSorted); + } else { + return outprops & + ~(kODeterministic | kAcceptor | kString | kILabelSorted | + kNotILabelSorted | kOLabelSorted | kNotOLabelSorted); + } + } else if (match_type_ == MATCH_OUTPUT) { + if (phi_label_ == 0) { + outprops &= ~kEpsilons | ~kIEpsilons | ~kOEpsilons; + outprops |= kNoEpsilons | kNoOEpsilons; + } + if (rewrite_both_) { + return outprops & + ~(kIDeterministic | kNonIDeterministic | kString | kILabelSorted | + kNotILabelSorted | kOLabelSorted | kNotOLabelSorted); + } else { + return outprops & + ~(kIDeterministic | kAcceptor | kString | kILabelSorted | + kNotILabelSorted | kOLabelSorted | kNotOLabelSorted); + } + } else { + // Shouldn't ever get here. + FSTERROR() << "PhiMatcher: Bad match type: " << match_type_; + return 0; + } +} + +// For any requested label that doesn't match at a state, this matcher +// considers all transitions that match the label 'rho_label' (rho = +// 'rest'). Each such rho transition found is returned with the +// rho_label rewritten as the requested label (both sides if an +// acceptor, or if 'rewrite_both' is true and both input and output +// labels of the found transition are 'rho_label'). If 'rho_label' is +// kNoLabel, this special matching is not done. RhoMatcher is +// templated itself on a matcher, which is used to perform the +// underlying matching. By default, the underlying matcher is +// constructed by RhoMatcher. The user can instead pass in this +// object; in that case, RhoMatcher takes its ownership. +// No non-consuming symbols other than epsilon supported with +// the underlying template argument matcher. +template +class RhoMatcher : public MatcherBase { + public: + using FST = typename M::FST; + using Arc = typename FST::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + // This makes a copy of the FST (w/o 'matcher' arg). + RhoMatcher(const FST &fst, MatchType match_type, Label rho_label = kNoLabel, + MatcherRewriteMode rewrite_mode = MATCHER_REWRITE_AUTO, + M *matcher = nullptr) + : matcher_(matcher ? matcher : new M(fst, match_type)), + match_type_(match_type), + rho_label_(rho_label), + error_(false), + state_(kNoStateId), + has_rho_(false) { + if (match_type == MATCH_BOTH) { + FSTERROR() << "RhoMatcher: Bad match type"; + match_type_ = MATCH_NONE; + error_ = true; + } + if (rho_label == 0) { + FSTERROR() << "RhoMatcher: 0 cannot be used as rho_label"; + rho_label_ = kNoLabel; + error_ = true; + } + if (rewrite_mode == MATCHER_REWRITE_AUTO) { + rewrite_both_ = fst.Properties(kAcceptor, true); + } else if (rewrite_mode == MATCHER_REWRITE_ALWAYS) { + rewrite_both_ = true; + } else { + rewrite_both_ = false; + } + } + + // This doesn't copy the FST. + RhoMatcher(const FST *fst, MatchType match_type, Label rho_label = kNoLabel, + MatcherRewriteMode rewrite_mode = MATCHER_REWRITE_AUTO, + M *matcher = nullptr) + : RhoMatcher(*fst, match_type, rho_label, rewrite_mode, + matcher ? matcher : new M(fst, match_type)) { } + + // This makes a copy of the FST. + RhoMatcher(const RhoMatcher &matcher, bool safe = false) + : matcher_(new M(*matcher.matcher_, safe)), + match_type_(matcher.match_type_), + rho_label_(matcher.rho_label_), + rewrite_both_(matcher.rewrite_both_), + error_(matcher.error_), + state_(kNoStateId), + has_rho_(false) {} + + RhoMatcher *Copy(bool safe = false) const override { + return new RhoMatcher(*this, safe); + } + + MatchType Type(bool test) const override { return matcher_->Type(test); } + + void SetState(StateId s) final { + if (state_ == s) return; + state_ = s; + matcher_->SetState(s); + has_rho_ = rho_label_ != kNoLabel; + } + + bool Find(Label label) final { + if (label == rho_label_ && rho_label_ != kNoLabel) { + FSTERROR() << "RhoMatcher::Find: bad label (rho)"; + error_ = true; + return false; + } + if (matcher_->Find(label)) { + rho_match_ = kNoLabel; + return true; + } else if (has_rho_ && label != 0 && label != kNoLabel && + (has_rho_ = matcher_->Find(rho_label_))) { + rho_match_ = label; + return true; + } else { + return false; + } + } + + bool Done() const final { return matcher_->Done(); } + + const Arc &Value() const final { + if (rho_match_ == kNoLabel) { + return matcher_->Value(); + } else { + rho_arc_ = matcher_->Value(); + if (rewrite_both_) { + if (rho_arc_.ilabel == rho_label_) rho_arc_.ilabel = rho_match_; + if (rho_arc_.olabel == rho_label_) rho_arc_.olabel = rho_match_; + } else if (match_type_ == MATCH_INPUT) { + rho_arc_.ilabel = rho_match_; + } else { + rho_arc_.olabel = rho_match_; + } + return rho_arc_; + } + } + + void Next() final { matcher_->Next(); } + + Weight Final(StateId s) const final { return matcher_->Final(s); } + + ssize_t Priority(StateId s) final { + state_ = s; + matcher_->SetState(s); + has_rho_ = matcher_->Find(rho_label_); + if (has_rho_) { + return kRequirePriority; + } else { + return matcher_->Priority(s); + } + } + + const FST &GetFst() const override { return matcher_->GetFst(); } + + uint64 Properties(uint64 props) const override; + + uint32 Flags() const override { + if (rho_label_ == kNoLabel || match_type_ == MATCH_NONE) { + return matcher_->Flags(); + } + return matcher_->Flags() | kRequireMatch; + } + + Label RhoLabel() const { return rho_label_; } + + private: + std::unique_ptr matcher_; + MatchType match_type_; // Type of match requested. + Label rho_label_; // Label that represents the rho transition + bool rewrite_both_; // Rewrite both sides when both are rho_label_? + Label rho_match_; // Current label that matches rho transition. + mutable Arc rho_arc_; // Arc to return when rho match. + bool error_; // Error encountered? + StateId state_; // Matcher state. + bool has_rho_; // Are there possibly rhos at the current state? +}; + +template +inline uint64 RhoMatcher::Properties(uint64 inprops) const { + auto outprops = matcher_->Properties(inprops); + if (error_) outprops |= kError; + if (match_type_ == MATCH_NONE) { + return outprops; + } else if (match_type_ == MATCH_INPUT) { + if (rewrite_both_) { + return outprops & + ~(kODeterministic | kNonODeterministic | kString | kILabelSorted | + kNotILabelSorted | kOLabelSorted | kNotOLabelSorted); + } else { + return outprops & + ~(kODeterministic | kAcceptor | kString | kILabelSorted | + kNotILabelSorted); + } + } else if (match_type_ == MATCH_OUTPUT) { + if (rewrite_both_) { + return outprops & + ~(kIDeterministic | kNonIDeterministic | kString | kILabelSorted | + kNotILabelSorted | kOLabelSorted | kNotOLabelSorted); + } else { + return outprops & + ~(kIDeterministic | kAcceptor | kString | kOLabelSorted | + kNotOLabelSorted); + } + } else { + // Shouldn't ever get here. + FSTERROR() << "RhoMatcher: Bad match type: " << match_type_; + return 0; + } +} + +// For any requested label, this matcher considers all transitions +// that match the label 'sigma_label' (sigma = "any"), and this in +// additions to transitions with the requested label. Each such sigma +// transition found is returned with the sigma_label rewritten as the +// requested label (both sides if an acceptor, or if 'rewrite_both' is +// true and both input and output labels of the found transition are +// 'sigma_label'). If 'sigma_label' is kNoLabel, this special +// matching is not done. SigmaMatcher is templated itself on a +// matcher, which is used to perform the underlying matching. By +// default, the underlying matcher is constructed by SigmaMatcher. +// The user can instead pass in this object; in that case, +// SigmaMatcher takes its ownership. No non-consuming symbols other +// than epsilon supported with the underlying template argument matcher. +template +class SigmaMatcher : public MatcherBase { + public: + using FST = typename M::FST; + using Arc = typename FST::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + // This makes a copy of the FST (w/o 'matcher' arg). + SigmaMatcher(const FST &fst, MatchType match_type, + Label sigma_label = kNoLabel, + MatcherRewriteMode rewrite_mode = MATCHER_REWRITE_AUTO, + M *matcher = nullptr) + : matcher_(matcher ? matcher : new M(fst, match_type)), + match_type_(match_type), + sigma_label_(sigma_label), + error_(false), + state_(kNoStateId) { + if (match_type == MATCH_BOTH) { + FSTERROR() << "SigmaMatcher: Bad match type"; + match_type_ = MATCH_NONE; + error_ = true; + } + if (sigma_label == 0) { + FSTERROR() << "SigmaMatcher: 0 cannot be used as sigma_label"; + sigma_label_ = kNoLabel; + error_ = true; + } + if (rewrite_mode == MATCHER_REWRITE_AUTO) { + rewrite_both_ = fst.Properties(kAcceptor, true); + } else if (rewrite_mode == MATCHER_REWRITE_ALWAYS) { + rewrite_both_ = true; + } else { + rewrite_both_ = false; + } + } + + // This doesn't copy the FST. + SigmaMatcher(const FST *fst, MatchType match_type, + Label sigma_label = kNoLabel, + MatcherRewriteMode rewrite_mode = MATCHER_REWRITE_AUTO, + M *matcher = nullptr) + : SigmaMatcher(*fst, match_type, sigma_label, rewrite_mode, + matcher ? matcher : new M(fst, match_type)) { } + + // This makes a copy of the FST. + SigmaMatcher(const SigmaMatcher &matcher, bool safe = false) + : matcher_(new M(*matcher.matcher_, safe)), + match_type_(matcher.match_type_), + sigma_label_(matcher.sigma_label_), + rewrite_both_(matcher.rewrite_both_), + error_(matcher.error_), + state_(kNoStateId) {} + + SigmaMatcher *Copy(bool safe = false) const override { + return new SigmaMatcher(*this, safe); + } + + MatchType Type(bool test) const override { return matcher_->Type(test); } + + void SetState(StateId s) final { + if (state_ == s) return; + state_ = s; + matcher_->SetState(s); + has_sigma_ = + (sigma_label_ != kNoLabel) ? matcher_->Find(sigma_label_) : false; + } + + bool Find(Label match_label) final { + match_label_ = match_label; + if (match_label == sigma_label_ && sigma_label_ != kNoLabel) { + FSTERROR() << "SigmaMatcher::Find: bad label (sigma)"; + error_ = true; + return false; + } + if (matcher_->Find(match_label)) { + sigma_match_ = kNoLabel; + return true; + } else if (has_sigma_ && match_label != 0 && match_label != kNoLabel && + matcher_->Find(sigma_label_)) { + sigma_match_ = match_label; + return true; + } else { + return false; + } + } + + bool Done() const final { return matcher_->Done(); } + + const Arc &Value() const final { + if (sigma_match_ == kNoLabel) { + return matcher_->Value(); + } else { + sigma_arc_ = matcher_->Value(); + if (rewrite_both_) { + if (sigma_arc_.ilabel == sigma_label_) sigma_arc_.ilabel = sigma_match_; + if (sigma_arc_.olabel == sigma_label_) sigma_arc_.olabel = sigma_match_; + } else if (match_type_ == MATCH_INPUT) { + sigma_arc_.ilabel = sigma_match_; + } else { + sigma_arc_.olabel = sigma_match_; + } + return sigma_arc_; + } + } + + void Next() final { + matcher_->Next(); + if (matcher_->Done() && has_sigma_ && (sigma_match_ == kNoLabel) && + (match_label_ > 0)) { + matcher_->Find(sigma_label_); + sigma_match_ = match_label_; + } + } + + Weight Final(StateId s) const final { return matcher_->Final(s); } + + ssize_t Priority(StateId s) final { + if (sigma_label_ != kNoLabel) { + SetState(s); + return has_sigma_ ? kRequirePriority : matcher_->Priority(s); + } else { + return matcher_->Priority(s); + } + } + + const FST &GetFst() const override { return matcher_->GetFst(); } + + uint64 Properties(uint64 props) const override; + + uint32 Flags() const override { + if (sigma_label_ == kNoLabel || match_type_ == MATCH_NONE) { + return matcher_->Flags(); + } + return matcher_->Flags() | kRequireMatch; + } + + Label SigmaLabel() const { return sigma_label_; } + + private: + std::unique_ptr matcher_; + MatchType match_type_; // Type of match requested. + Label sigma_label_; // Label that represents the sigma transition. + bool rewrite_both_; // Rewrite both sides when both are sigma_label_? + bool has_sigma_; // Are there sigmas at the current state? + Label sigma_match_; // Current label that matches sigma transition. + mutable Arc sigma_arc_; // Arc to return when sigma match. + Label match_label_; // Label being matched. + bool error_; // Error encountered? + StateId state_; // Matcher state. +}; + +template +inline uint64 SigmaMatcher::Properties(uint64 inprops) const { + auto outprops = matcher_->Properties(inprops); + if (error_) outprops |= kError; + if (match_type_ == MATCH_NONE) { + return outprops; + } else if (rewrite_both_) { + return outprops & + ~(kIDeterministic | kNonIDeterministic | kODeterministic | + kNonODeterministic | kILabelSorted | kNotILabelSorted | + kOLabelSorted | kNotOLabelSorted | kString); + } else if (match_type_ == MATCH_INPUT) { + return outprops & + ~(kIDeterministic | kNonIDeterministic | kODeterministic | + kNonODeterministic | kILabelSorted | kNotILabelSorted | kString | + kAcceptor); + } else if (match_type_ == MATCH_OUTPUT) { + return outprops & + ~(kIDeterministic | kNonIDeterministic | kODeterministic | + kNonODeterministic | kOLabelSorted | kNotOLabelSorted | kString | + kAcceptor); + } else { + // Shouldn't ever get here. + FSTERROR() << "SigmaMatcher: Bad match type: " << match_type_; + return 0; + } +} + +// Flags for MultiEpsMatcher. + +// Return multi-epsilon arcs for Find(kNoLabel). +const uint32 kMultiEpsList = 0x00000001; + +// Return a kNolabel loop for Find(multi_eps). +const uint32 kMultiEpsLoop = 0x00000002; + +// MultiEpsMatcher: allows treating multiple non-0 labels as +// non-consuming labels in addition to 0 that is always +// non-consuming. Precise behavior controlled by 'flags' argument. By +// default, the underlying matcher is constructed by +// MultiEpsMatcher. The user can instead pass in this object; in that +// case, MultiEpsMatcher takes its ownership iff 'own_matcher' is +// true. +template +class MultiEpsMatcher { + public: + using FST = typename M::FST; + using Arc = typename FST::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + // This makes a copy of the FST (w/o 'matcher' arg). + MultiEpsMatcher(const FST &fst, MatchType match_type, + uint32 flags = (kMultiEpsLoop | kMultiEpsList), + M *matcher = nullptr, bool own_matcher = true) + : matcher_(matcher ? matcher : new M(fst, match_type)), + flags_(flags), + own_matcher_(matcher ? own_matcher : true) { + Init(match_type); + } + + // This doesn't copy the FST. + MultiEpsMatcher(const FST *fst, MatchType match_type, + uint32 flags = (kMultiEpsLoop | kMultiEpsList), + M *matcher = nullptr, bool own_matcher = true) + : matcher_(matcher ? matcher : new M(fst, match_type)), + flags_(flags), + own_matcher_(matcher ? own_matcher : true) { + Init(match_type); + } + + // This makes a copy of the FST. + MultiEpsMatcher(const MultiEpsMatcher &matcher, bool safe = false) + : matcher_(new M(*matcher.matcher_, safe)), + flags_(matcher.flags_), + own_matcher_(true), + multi_eps_labels_(matcher.multi_eps_labels_), + loop_(matcher.loop_) { + loop_.nextstate = kNoStateId; + } + + ~MultiEpsMatcher() { + if (own_matcher_) delete matcher_; + } + + MultiEpsMatcher *Copy(bool safe = false) const { + return new MultiEpsMatcher(*this, safe); + } + + MatchType Type(bool test) const { return matcher_->Type(test); } + + void SetState(StateId state) { + matcher_->SetState(state); + loop_.nextstate = state; + } + + bool Find(Label label); + + bool Done() const { return done_; } + + const Arc &Value() const { return current_loop_ ? loop_ : matcher_->Value(); } + + void Next() { + if (!current_loop_) { + matcher_->Next(); + done_ = matcher_->Done(); + if (done_ && multi_eps_iter_ != multi_eps_labels_.End()) { + ++multi_eps_iter_; + while ((multi_eps_iter_ != multi_eps_labels_.End()) && + !matcher_->Find(*multi_eps_iter_)) { + ++multi_eps_iter_; + } + if (multi_eps_iter_ != multi_eps_labels_.End()) { + done_ = false; + } else { + done_ = !matcher_->Find(kNoLabel); + } + } + } else { + done_ = true; + } + } + + const FST &GetFst() const { return matcher_->GetFst(); } + + uint64 Properties(uint64 props) const { return matcher_->Properties(props); } + + const M *GetMatcher() const { return matcher_; } + + Weight Final(StateId s) const { return matcher_->Final(s); } + + uint32 Flags() const { return matcher_->Flags(); } + + ssize_t Priority(StateId s) { return matcher_->Priority(s); } + + void AddMultiEpsLabel(Label label) { + if (label == 0) { + FSTERROR() << "MultiEpsMatcher: Bad multi-eps label: 0"; + } else { + multi_eps_labels_.Insert(label); + } + } + + void RemoveMultiEpsLabel(Label label) { + if (label == 0) { + FSTERROR() << "MultiEpsMatcher: Bad multi-eps label: 0"; + } else { + multi_eps_labels_.Erase(label); + } + } + + void ClearMultiEpsLabels() { multi_eps_labels_.Clear(); } + + private: + void Init(MatchType match_type) { + if (match_type == MATCH_INPUT) { + loop_.ilabel = kNoLabel; + loop_.olabel = 0; + } else { + loop_.ilabel = 0; + loop_.olabel = kNoLabel; + } + loop_.weight = Weight::One(); + loop_.nextstate = kNoStateId; + } + + M *matcher_; + uint32 flags_; + bool own_matcher_; // Does this class delete the matcher? + + // Multi-eps label set. + CompactSet multi_eps_labels_; + typename CompactSet::const_iterator multi_eps_iter_; + + bool current_loop_; // Current arc is the implicit loop? + mutable Arc loop_; // For non-consuming symbols. + bool done_; // Matching done? + + MultiEpsMatcher &operator=(const MultiEpsMatcher &) = delete; +}; + +template +inline bool MultiEpsMatcher::Find(Label label) { + multi_eps_iter_ = multi_eps_labels_.End(); + current_loop_ = false; + bool ret; + if (label == 0) { + ret = matcher_->Find(0); + } else if (label == kNoLabel) { + if (flags_ & kMultiEpsList) { + // Returns all non-consuming arcs (including epsilon). + multi_eps_iter_ = multi_eps_labels_.Begin(); + while ((multi_eps_iter_ != multi_eps_labels_.End()) && + !matcher_->Find(*multi_eps_iter_)) { + ++multi_eps_iter_; + } + if (multi_eps_iter_ != multi_eps_labels_.End()) { + ret = true; + } else { + ret = matcher_->Find(kNoLabel); + } + } else { + // Returns all epsilon arcs. + ret = matcher_->Find(kNoLabel); + } + } else if ((flags_ & kMultiEpsLoop) && + multi_eps_labels_.Find(label) != multi_eps_labels_.End()) { + // Returns implicit loop. + current_loop_ = true; + ret = true; + } else { + ret = matcher_->Find(label); + } + done_ = !ret; + return ret; +} + +// This class discards any implicit matches (e.g., the implicit epsilon +// self-loops in the SortedMatcher). Matchers are most often used in +// composition/intersection where the implicit matches are needed +// e.g. for epsilon processing. However, if a matcher is simply being +// used to look-up explicit label matches, this class saves the user +// from having to check for and discard the unwanted implicit matches +// themselves. +template +class ExplicitMatcher : public MatcherBase { + public: + using FST = typename M::FST; + using Arc = typename FST::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + // This makes a copy of the FST. + ExplicitMatcher(const FST &fst, MatchType match_type, M *matcher = nullptr) + : matcher_(matcher ? matcher : new M(fst, match_type)), + match_type_(match_type), + error_(false) {} + + // This doesn't copy the FST. + ExplicitMatcher(const FST *fst, MatchType match_type, M *matcher = nullptr) + : matcher_(matcher ? matcher : new M(fst, match_type)), + match_type_(match_type), + error_(false) {} + + // This makes a copy of the FST. + ExplicitMatcher(const ExplicitMatcher &matcher, bool safe = false) + : matcher_(new M(*matcher.matcher_, safe)), + match_type_(matcher.match_type_), + error_(matcher.error_) {} + + ExplicitMatcher *Copy(bool safe = false) const override { + return new ExplicitMatcher(*this, safe); + } + + MatchType Type(bool test) const override { return matcher_->Type(test); } + + void SetState(StateId s) final { matcher_->SetState(s); } + + bool Find(Label label) final { + matcher_->Find(label); + CheckArc(); + return !Done(); + } + + bool Done() const final { return matcher_->Done(); } + + const Arc &Value() const final { return matcher_->Value(); } + + void Next() final { + matcher_->Next(); + CheckArc(); + } + + Weight Final(StateId s) const final { return matcher_->Final(s); } + + ssize_t Priority(StateId s) final { return matcher_->Priority(s); } + + const FST &GetFst() const final { return matcher_->GetFst(); } + + uint64 Properties(uint64 inprops) const override { + return matcher_->Properties(inprops); + } + + const M *GetMatcher() const { return matcher_.get(); } + + uint32 Flags() const override { return matcher_->Flags(); } + + private: + // Checks current arc if available and explicit. If not available, stops. If + // not explicit, checks next ones. + void CheckArc() { + for (; !matcher_->Done(); matcher_->Next()) { + const auto label = match_type_ == MATCH_INPUT ? matcher_->Value().ilabel + : matcher_->Value().olabel; + if (label != kNoLabel) return; + } + } + + std::unique_ptr matcher_; + MatchType match_type_; // Type of match requested. + bool error_; // Error encountered? +}; + +// Generic matcher, templated on the FST definition. +// +// Here is a typical use: +// +// Matcher matcher(fst, MATCH_INPUT); +// matcher.SetState(state); +// if (matcher.Find(label)) +// for (; !matcher.Done(); matcher.Next()) { +// auto &arc = matcher.Value(); +// ... +// } +template +class Matcher { + public: + using FST = F; + using Arc = typename F::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + // This makes a copy of the FST. + Matcher(const FST &fst, MatchType match_type) + : owned_fst_(fst.Copy()), + base_(owned_fst_->InitMatcher(match_type)) { + if (!base_) base_.reset(new SortedMatcher(owned_fst_.get(), + match_type)); + } + + // This doesn't copy the FST. + Matcher(const FST *fst, MatchType match_type) + : base_(fst->InitMatcher(match_type)) { + if (!base_) base_.reset(new SortedMatcher(fst, match_type)); + } + + // This makes a copy of the FST. + Matcher(const Matcher &matcher, bool safe = false) + : base_(matcher.base_->Copy(safe)) { } + + // Takes ownership of the provided matcher. + explicit Matcher(MatcherBase *base_matcher) + : base_(base_matcher) { } + + Matcher *Copy(bool safe = false) const { + return new Matcher(*this, safe); + } + + MatchType Type(bool test) const { return base_->Type(test); } + + void SetState(StateId s) { base_->SetState(s); } + + bool Find(Label label) { return base_->Find(label); } + + bool Done() const { return base_->Done(); } + + const Arc &Value() const { return base_->Value(); } + + void Next() { base_->Next(); } + + const FST &GetFst() const { + return static_cast(base_->GetFst()); + } + + uint64 Properties(uint64 props) const { return base_->Properties(props); } + + Weight Final(StateId s) const { return base_->Final(s); } + + uint32 Flags() const { return base_->Flags() & kMatcherFlags; } + + ssize_t Priority(StateId s) { return base_->Priority(s); } + + private: + std::unique_ptr owned_fst_; + std::unique_ptr> base_; +}; + +} // namespace fst + +#endif // FST_MATCHER_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/memory.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/memory.h new file mode 100644 index 0000000000..c1f0bddc71 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/memory.h @@ -0,0 +1,443 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// FST memory utilities. + +#ifndef FST_MEMORY_H_ +#define FST_MEMORY_H_ + +#include +#include +#include +#include + +#include +#include +#include + +namespace fst { + +// Default block allocation size. +constexpr int kAllocSize = 64; + +// Minimum number of allocations per block. +constexpr int kAllocFit = 4; + +// Base class for MemoryArena that allows (e.g.) MemoryArenaCollection to +// easily manipulate collections of variously sized arenas. +class MemoryArenaBase { + public: + virtual ~MemoryArenaBase() {} + virtual size_t Size() const = 0; +}; + +namespace internal { + +// Allocates 'size' unintialized memory chunks of size object_size from +// underlying blocks of (at least) size 'block_size * object_size'. +// All blocks are freed when this class is deleted. Result of allocate() will +// be aligned to object_size. +template +class MemoryArenaImpl : public MemoryArenaBase { + public: + enum { kObjectSize = object_size }; + + explicit MemoryArenaImpl(size_t block_size = kAllocSize) + : block_size_(block_size * kObjectSize), block_pos_(0) { + blocks_.emplace_front(new char[block_size_]); + } + + void *Allocate(size_t size) { + const auto byte_size = size * kObjectSize; + if (byte_size * kAllocFit > block_size_) { + // Large block; adds new large block. + auto *ptr = new char[byte_size]; + blocks_.emplace_back(ptr); + return ptr; + } + if (block_pos_ + byte_size > block_size_) { + // Doesn't fit; adds new standard block. + auto *ptr = new char[block_size_]; + block_pos_ = 0; + blocks_.emplace_front(ptr); + } + // Fits; uses current block. + auto *ptr = blocks_.front().get() + block_pos_; + block_pos_ += byte_size; + return ptr; + } + + size_t Size() const override { return kObjectSize; } + + private: + const size_t block_size_; // Default block size in bytes. + size_t block_pos_; // Current position in block in bytes. + std::list> blocks_; // List of allocated blocks. +}; + +} // namespace internal + +template +using MemoryArena = internal::MemoryArenaImpl; + +// Base class for MemoryPool that allows (e.g.) MemoryPoolCollection to easily +// manipulate collections of variously sized pools. +class MemoryPoolBase { + public: + virtual ~MemoryPoolBase() {} + virtual size_t Size() const = 0; +}; + +namespace internal { + +// Allocates and frees initially uninitialized memory chunks of size +// object_size. Keeps an internal list of freed chunks that are reused (as is) +// on the next allocation if available. Chunks are constructed in blocks of size +// 'pool_size'. +template +class MemoryPoolImpl : public MemoryPoolBase { + public: + enum { kObjectSize = object_size }; + + struct Link { + char buf[kObjectSize]; + Link *next; + }; + + explicit MemoryPoolImpl(size_t pool_size) + : mem_arena_(pool_size), free_list_(nullptr) {} + + void *Allocate() { + if (free_list_ == nullptr) { + auto *link = static_cast(mem_arena_.Allocate(1)); + link->next = nullptr; + return link; + } else { + auto *link = free_list_; + free_list_ = link->next; + return link; + } + } + + void Free(void *ptr) { + if (ptr) { + auto *link = static_cast(ptr); + link->next = free_list_; + free_list_ = link; + } + } + + size_t Size() const override { return kObjectSize; } + + private: + MemoryArena mem_arena_; + Link *free_list_; + + MemoryPoolImpl(const MemoryPoolImpl &) = delete; + MemoryPoolImpl &operator=(const MemoryPoolImpl &) = delete; +}; + +} // namespace internal + +// Allocates and frees initially uninitialized memory chunks of size sizeof(T). +// All memory is freed when the class is deleted. The result of Allocate() will +// be suitably memory-aligned. Combined with placement operator new and destroy +// functions for the T class, this can be used to improve allocation efficiency. +// See nlp/fst/lib/visit.h (global new) and nlp/fst/lib/dfs-visit.h (class new) +// for examples. +template +class MemoryPool : public internal::MemoryPoolImpl { + public: + // 'pool_size' specifies the size of the initial pool and how it is extended. + MemoryPool(size_t pool_size = kAllocSize) + : internal::MemoryPoolImpl(pool_size) {} +}; + +// Stores a collection of memory arenas. +class MemoryArenaCollection { + public: + // 'block_size' specifies the block size of the arenas. + explicit MemoryArenaCollection(size_t block_size = kAllocSize) + : block_size_(block_size), ref_count_(1) {} + + template + MemoryArena *Arena() { + if (sizeof(T) >= arenas_.size()) arenas_.resize(sizeof(T) + 1); + MemoryArenaBase *arena = arenas_[sizeof(T)].get(); + if (arena == nullptr) { + arena = new MemoryArena(block_size_); + arenas_[sizeof(T)].reset(arena); + } + return static_cast *>(arena); + } + + size_t BlockSize() const { return block_size_; } + + size_t RefCount() const { return ref_count_; } + + size_t IncrRefCount() { return ++ref_count_; } + + size_t DecrRefCount() { return --ref_count_; } + + private: + size_t block_size_; + size_t ref_count_; + std::vector> arenas_; +}; + +// Stores a collection of memory pools +class MemoryPoolCollection { + public: + // 'pool_size' specifies the size of initial pool and how it is extended. + explicit MemoryPoolCollection(size_t pool_size = kAllocSize) + : pool_size_(pool_size), ref_count_(1) {} + + template + MemoryPool *Pool() { + if (sizeof(T) >= pools_.size()) pools_.resize(sizeof(T) + 1); + MemoryPoolBase *pool = pools_[sizeof(T)].get(); + if (pool == nullptr) { + pool = new MemoryPool(pool_size_); + pools_[sizeof(T)].reset(pool); + } + return static_cast *>(pool); + } + + size_t PoolSize() const { return pool_size_; } + + size_t RefCount() const { return ref_count_; } + + size_t IncrRefCount() { return ++ref_count_; } + + size_t DecrRefCount() { return --ref_count_; } + + private: + size_t pool_size_; + size_t ref_count_; + std::vector> pools_; +}; + +// STL allocator using memory arenas. Memory is allocated from underlying +// blocks of size 'block_size * sizeof(T)'. Memory is freed only when all +// objects using this allocator are destroyed and there is otherwise no reuse +// (unlike PoolAllocator). +// +// This allocator has object-local state so it should not be used with splicing +// or swapping operations between objects created with different allocators nor +// should it be used if copies must be thread-safe. The result of allocate() +// will be suitably memory-aligned. +template +class BlockAllocator { + public: + using Allocator = std::allocator; + using size_type = typename Allocator::size_type; + using difference_type = typename Allocator::difference_type; + using pointer = typename Allocator::pointer; + using const_pointer = typename Allocator::const_pointer; + using reference = typename Allocator::reference; + using const_reference = typename Allocator::const_reference; + using value_type = typename Allocator::value_type; + + template + struct rebind { + using other = BlockAllocator; + }; + + explicit BlockAllocator(size_t block_size = kAllocSize) + : arenas_(new MemoryArenaCollection(block_size)) {} + + BlockAllocator(const BlockAllocator &arena_alloc) + : arenas_(arena_alloc.Arenas()) { + Arenas()->IncrRefCount(); + } + + template + explicit BlockAllocator(const BlockAllocator &arena_alloc) + : arenas_(arena_alloc.Arenas()) { + Arenas()->IncrRefCount(); + } + + ~BlockAllocator() { + if (Arenas()->DecrRefCount() == 0) delete Arenas(); + } + + pointer address(reference ref) const { return Allocator().address(ref); } + + const_pointer address(const_reference ref) const { + return Allocator().address(ref); + } + + size_type max_size() const { return Allocator().max_size(); } + + template + void construct(U *p, Args &&... args) { + Allocator().construct(p, std::forward(args)...); + } + + void destroy(pointer p) { Allocator().destroy(p); } + + pointer allocate(size_type n, const void *hint = nullptr) { + if (n * kAllocFit <= kAllocSize) { + return static_cast(Arena()->Allocate(n)); + } else { + return Allocator().allocate(n, hint); + } + } + + void deallocate(pointer p, size_type n) { + if (n * kAllocFit > kAllocSize) Allocator().deallocate(p, n); + } + + MemoryArenaCollection *Arenas() const { return arenas_; } + + private: + MemoryArena *Arena() { return arenas_->Arena(); } + + MemoryArenaCollection *arenas_; + + BlockAllocator operator=(const BlockAllocator &); +}; + +template +bool operator==(const BlockAllocator &alloc1, + const BlockAllocator &alloc2) { + return false; +} + +template +bool operator!=(const BlockAllocator &alloc1, + const BlockAllocator &alloc2) { + return true; +} + +// STL allocator using memory pools. Memory is allocated from underlying +// blocks of size 'block_size * sizeof(T)'. Keeps an internal list of freed +// chunks thare are reused on the next allocation. +// +// This allocator has object-local state so it should not be used with splicing +// or swapping operations between objects created with different allocators nor +// should it be used if copies must be thread-safe. The result of allocate() +// will be suitably memory-aligned. +template +class PoolAllocator { + public: + using Allocator = std::allocator; + using size_type = typename Allocator::size_type; + using difference_type = typename Allocator::difference_type; + using pointer = typename Allocator::pointer; + using const_pointer = typename Allocator::const_pointer; + using reference = typename Allocator::reference; + using const_reference = typename Allocator::const_reference; + using value_type = typename Allocator::value_type; + + template + struct rebind { + using other = PoolAllocator; + }; + + explicit PoolAllocator(size_t pool_size = kAllocSize) + : pools_(new MemoryPoolCollection(pool_size)) {} + + PoolAllocator(const PoolAllocator &pool_alloc) + : pools_(pool_alloc.Pools()) { + Pools()->IncrRefCount(); + } + + template + explicit PoolAllocator(const PoolAllocator &pool_alloc) + : pools_(pool_alloc.Pools()) { + Pools()->IncrRefCount(); + } + + ~PoolAllocator() { + if (Pools()->DecrRefCount() == 0) delete Pools(); + } + + pointer address(reference ref) const { return Allocator().address(ref); } + + const_pointer address(const_reference ref) const { + return Allocator().address(ref); + } + + size_type max_size() const { return Allocator().max_size(); } + + template + void construct(U *p, Args &&... args) { + Allocator().construct(p, std::forward(args)...); + } + + void destroy(pointer p) { Allocator().destroy(p); } + + pointer allocate(size_type n, const void *hint = nullptr) { + if (n == 1) { + return static_cast(Pool<1>()->Allocate()); + } else if (n == 2) { + return static_cast(Pool<2>()->Allocate()); + } else if (n <= 4) { + return static_cast(Pool<4>()->Allocate()); + } else if (n <= 8) { + return static_cast(Pool<8>()->Allocate()); + } else if (n <= 16) { + return static_cast(Pool<16>()->Allocate()); + } else if (n <= 32) { + return static_cast(Pool<32>()->Allocate()); + } else if (n <= 64) { + return static_cast(Pool<64>()->Allocate()); + } else { + return Allocator().allocate(n, hint); + } + } + + void deallocate(pointer p, size_type n) { + if (n == 1) { + Pool<1>()->Free(p); + } else if (n == 2) { + Pool<2>()->Free(p); + } else if (n <= 4) { + Pool<4>()->Free(p); + } else if (n <= 8) { + Pool<8>()->Free(p); + } else if (n <= 16) { + Pool<16>()->Free(p); + } else if (n <= 32) { + Pool<32>()->Free(p); + } else if (n <= 64) { + Pool<64>()->Free(p); + } else { + Allocator().deallocate(p, n); + } + } + + MemoryPoolCollection *Pools() const { return pools_; } + + private: + template + struct TN { + T buf[n]; + }; + + template + MemoryPool> *Pool() { + return pools_->Pool>(); + } + + MemoryPoolCollection *pools_; + + PoolAllocator operator=(const PoolAllocator &); +}; + +template +bool operator==(const PoolAllocator &alloc1, + const PoolAllocator &alloc2) { + return false; +} + +template +bool operator!=(const PoolAllocator &alloc1, + const PoolAllocator &alloc2) { + return true; +} + +} // namespace fst + +#endif // FST_MEMORY_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/minimize.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/minimize.h new file mode 100644 index 0000000000..23947846c6 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/minimize.h @@ -0,0 +1,568 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Functions and classes to minimize an FST. + +#ifndef FST_MINIMIZE_H_ +#define FST_MINIMIZE_H_ + +#include + +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace fst { +namespace internal { + +// Comparator for creating partition. +template +class StateComparator { + public: + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + StateComparator(const Fst &fst, const Partition &partition) + : fst_(fst), partition_(partition) {} + + // Compares state x with state y based on sort criteria. + bool operator()(const StateId x, const StateId y) const { + // Checks for final state equivalence. + const auto xfinal = fst_.Final(x).Hash(); + const auto yfinal = fst_.Final(y).Hash(); + if (xfinal < yfinal) { + return true; + } else if (xfinal > yfinal) { + return false; + } + // Checks for number of arcs. + if (fst_.NumArcs(x) < fst_.NumArcs(y)) return true; + if (fst_.NumArcs(x) > fst_.NumArcs(y)) return false; + // If the number of arcs are equal, checks for arc match. + for (ArcIterator> aiter1(fst_, x), aiter2(fst_, y); + !aiter1.Done() && !aiter2.Done(); aiter1.Next(), aiter2.Next()) { + const auto &arc1 = aiter1.Value(); + const auto &arc2 = aiter2.Value(); + if (arc1.ilabel < arc2.ilabel) return true; + if (arc1.ilabel > arc2.ilabel) return false; + if (partition_.ClassId(arc1.nextstate) < + partition_.ClassId(arc2.nextstate)) + return true; + if (partition_.ClassId(arc1.nextstate) > + partition_.ClassId(arc2.nextstate)) + return false; + } + return false; + } + + private: + const Fst &fst_; + const Partition &partition_; +}; + +// Computes equivalence classes for cyclic unweighted acceptors. For cyclic +// minimization we use the classic Hopcroft minimization algorithm, which has +// complexity O(E log V) where E is the number of arcs and V is the number of +// states. +// +// For more information, see: +// +// Hopcroft, J. 1971. An n Log n algorithm for minimizing states in a finite +// automaton. Ms, Stanford University. +// +// Note: the original presentation of the paper was for a finite automaton (== +// deterministic, unweighted acceptor), but we also apply it to the +// nondeterministic case, where it is also applicable as long as the semiring is +// idempotent (if the semiring is not idempotent, there are some complexities +// in keeping track of the weight when there are multiple arcs to states that +// will be merged, and we don't deal with this). +template +class CyclicMinimizer { + public: + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using ClassId = typename Arc::StateId; + using Weight = typename Arc::Weight; + using RevArc = ReverseArc; + + explicit CyclicMinimizer(const ExpandedFst &fst) { + Initialize(fst); + Compute(fst); + } + + const Partition &GetPartition() const { return P_; } + + private: + // StateILabelHasher is a hashing object that computes a hash-function + // of an FST state that depends only on the set of ilabels on arcs leaving + // the state [note: it assumes that the arcs are ilabel-sorted]. + // In order to work correctly for non-deterministic automata, multiple + // instances of the same ilabel count the same as a single instance. + class StateILabelHasher { + public: + explicit StateILabelHasher(const Fst &fst) : fst_(fst) {} + + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + + size_t operator()(const StateId s) { + const size_t p1 = 7603; + const size_t p2 = 433024223; + size_t result = p2; + size_t current_ilabel = kNoLabel; + for (ArcIterator> aiter(fst_, s); !aiter.Done(); aiter.Next()) { + Label this_ilabel = aiter.Value().ilabel; + if (this_ilabel != current_ilabel) { // Ignores repeats. + result = p1 * result + this_ilabel; + current_ilabel = this_ilabel; + } + } + return result; + } + + private: + const Fst &fst_; + }; + + class ArcIterCompare { + public: + explicit ArcIterCompare(const Partition &partition) + : partition_(partition) {} + + ArcIterCompare(const ArcIterCompare &comp) : partition_(comp.partition_) {} + + // Compares two iterators based on their input labels. + bool operator()(const ArcIterator> *x, + const ArcIterator> *y) const { + const auto &xarc = x->Value(); + const auto &yarc = y->Value(); + return xarc.ilabel > yarc.ilabel; + } + + private: + const Partition &partition_; + }; + + using ArcIterQueue = + std::priority_queue> *, + std::vector> *>, + ArcIterCompare>; + + private: + // Prepartitions the space into equivalence classes. We ensure that final and + // non-final states always go into different equivalence classes, and we use + // class StateILabelHasher to make sure that most of the time, states with + // different sets of ilabels on arcs leaving them, go to different partitions. + // Note: for the O(n) guarantees we don't rely on the goodness of this + // hashing function---it just provides a bonus speedup. + void PrePartition(const ExpandedFst &fst) { + VLOG(5) << "PrePartition"; + StateId next_class = 0; + auto num_states = fst.NumStates(); + // Allocates a temporary vector to store the initial class mappings, so that + // we can allocate the classes all at once. + std::vector state_to_initial_class(num_states); + { + // We maintain two maps from hash-value to class---one for final states + // (final-prob == One()) and one for non-final states + // (final-prob == Zero()). We are processing unweighted acceptors, so the + // are the only two possible values. + using HashToClassMap = std::unordered_map; + HashToClassMap hash_to_class_nonfinal; + HashToClassMap hash_to_class_final; + StateILabelHasher hasher(fst); + for (StateId s = 0; s < num_states; ++s) { + size_t hash = hasher(s); + HashToClassMap &this_map = + (fst.Final(s) != Weight::Zero() ? hash_to_class_final + : hash_to_class_nonfinal); + // Avoids two map lookups by using 'insert' instead of 'find'. + auto p = this_map.insert(std::make_pair(hash, next_class)); + state_to_initial_class[s] = p.second ? next_class++ : p.first->second; + } + // Lets the unordered_maps go out of scope before we allocate the classes, + // to reduce the maximum amount of memory used. + } + P_.AllocateClasses(next_class); + for (StateId s = 0; s < num_states; ++s) { + P_.Add(s, state_to_initial_class[s]); + } + for (StateId c = 0; c < next_class; ++c) L_.Enqueue(c); + VLOG(5) << "Initial Partition: " << P_.NumClasses(); + } + + // Creates inverse transition Tr_ = rev(fst), loops over states in FST and + // splits on final, creating two blocks in the partition corresponding to + // final, non-final. + void Initialize(const ExpandedFst &fst) { + // Constructs Tr. + Reverse(fst, &Tr_); + ILabelCompare ilabel_comp; + ArcSort(&Tr_, ilabel_comp); + // Tells the partition how many elements to allocate. The first state in + // Tr_ is super-final state. + P_.Initialize(Tr_.NumStates() - 1); + // Prepares initial partition. + PrePartition(fst); + // Allocates arc iterator queue. + ArcIterCompare comp(P_); + aiter_queue_.reset(new ArcIterQueue(comp)); + } + // Partitions all classes with destination C. + void Split(ClassId C) { + // Prepares priority queue: opens arc iterator for each state in C, and + // inserts into priority queue. + for (PartitionIterator siter(P_, C); !siter.Done(); siter.Next()) { + StateId s = siter.Value(); + if (Tr_.NumArcs(s + 1)) { + aiter_queue_->push(new ArcIterator>(Tr_, s + 1)); + } + } + // Now pops arc iterator from queue, splits entering equivalence class, and + // re-inserts updated iterator into queue. + Label prev_label = -1; + while (!aiter_queue_->empty()) { + std::unique_ptr>> aiter(aiter_queue_->top()); + aiter_queue_->pop(); + if (aiter->Done()) continue; + const auto &arc = aiter->Value(); + auto from_state = aiter->Value().nextstate - 1; + auto from_label = arc.ilabel; + if (prev_label != from_label) P_.FinalizeSplit(&L_); + auto from_class = P_.ClassId(from_state); + if (P_.ClassSize(from_class) > 1) P_.SplitOn(from_state); + prev_label = from_label; + aiter->Next(); + if (!aiter->Done()) aiter_queue_->push(aiter.release()); + } + P_.FinalizeSplit(&L_); + } + + // Main loop for Hopcroft minimization. + void Compute(const Fst &fst) { + // Processes active classes (FIFO, or FILO). + while (!L_.Empty()) { + const auto C = L_.Head(); + L_.Dequeue(); + Split(C); // Splits on C, all labels in C. + } + } + + private: + // Partioning of states into equivalence classes. + Partition P_; + // Set of active classes to be processed in partition P. + Queue L_; + // Reverses transition function. + VectorFst Tr_; + // Priority queue of open arc iterators for all states in the splitter + // equivalence class. + std::unique_ptr aiter_queue_; +}; + +// Computes equivalence classes for acyclic FST. +// +// Complexity: +// +// O(E) +// +// where E is the number of arcs. +// +// For more information, see: +// +// Revuz, D. 1992. Minimization of acyclic deterministic automata in linear +// time. Theoretical Computer Science 92(1): 181-189. +template +class AcyclicMinimizer { + public: + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using ClassId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + explicit AcyclicMinimizer(const ExpandedFst &fst) { + Initialize(fst); + Refine(fst); + } + + const Partition &GetPartition() { return partition_; } + + private: + // DFS visitor to compute the height (distance) to final state. + class HeightVisitor { + public: + HeightVisitor() : max_height_(0), num_states_(0) {} + + // Invoked before DFS visit. + void InitVisit(const Fst &fst) {} + + // Invoked when state is discovered (2nd arg is DFS tree root). + bool InitState(StateId s, StateId root) { + // Extends height array and initialize height (distance) to 0. + for (StateId i = height_.size(); i <= s; ++i) height_.push_back(-1); + if (s >= num_states_) num_states_ = s + 1; + return true; + } + + // Invoked when tree arc examined (to undiscovered state). + bool TreeArc(StateId s, const Arc &arc) { return true; } + + // Invoked when back arc examined (to unfinished state). + bool BackArc(StateId s, const Arc &arc) { return true; } + + // Invoked when forward or cross arc examined (to finished state). + bool ForwardOrCrossArc(StateId s, const Arc &arc) { + if (height_[arc.nextstate] + 1 > height_[s]) { + height_[s] = height_[arc.nextstate] + 1; + } + return true; + } + + // Invoked when state finished (parent is kNoStateId for tree root). + void FinishState(StateId s, StateId parent, const Arc *parent_arc) { + if (height_[s] == -1) height_[s] = 0; + const auto h = height_[s] + 1; + if (parent >= 0) { + if (h > height_[parent]) height_[parent] = h; + if (h > max_height_) max_height_ = h; + } + } + + // Invoked after DFS visit. + void FinishVisit() {} + + size_t max_height() const { return max_height_; } + + const std::vector &height() const { return height_; } + + size_t num_states() const { return num_states_; } + + private: + std::vector height_; + size_t max_height_; + size_t num_states_; + }; + + private: + // Cluster states according to height (distance to final state) + void Initialize(const Fst &fst) { + // Computes height (distance to final state). + HeightVisitor hvisitor; + DfsVisit(fst, &hvisitor); + // Creates initial partition based on height. + partition_.Initialize(hvisitor.num_states()); + partition_.AllocateClasses(hvisitor.max_height() + 1); + const auto &hstates = hvisitor.height(); + for (StateId s = 0; s < hstates.size(); ++s) partition_.Add(s, hstates[s]); + } + + // Refines states based on arc sort (out degree, arc equivalence). + void Refine(const Fst &fst) { + using EquivalenceMap = std::map>; + StateComparator comp(fst, partition_); + // Starts with tail (height = 0). + auto height = partition_.NumClasses(); + for (StateId h = 0; h < height; ++h) { + EquivalenceMap equiv_classes(comp); + // Sorts states within equivalence class. + PartitionIterator siter(partition_, h); + equiv_classes[siter.Value()] = h; + for (siter.Next(); !siter.Done(); siter.Next()) { + auto insert_result = + equiv_classes.insert(std::make_pair(siter.Value(), kNoStateId)); + if (insert_result.second) { + insert_result.first->second = partition_.AddClass(); + } + } + // Creates refined partition. + for (siter.Reset(); !siter.Done();) { + const auto s = siter.Value(); + const auto old_class = partition_.ClassId(s); + const auto new_class = equiv_classes[s]; + // A move operation can invalidate the iterator, so we first update + // the iterator to the next element before we move the current element + // out of the list. + siter.Next(); + if (old_class != new_class) partition_.Move(s, new_class); + } + } + } + + private: + Partition partition_; +}; + +// Given a partition and a Mutable FST, merges states of Fst in place (i.e., +// destructively). Merging works by taking the first state in a class of the +// partition to be the representative state for the class. Each arc is then +// reconnected to this state. All states in the class are merged by adding +// their arcs to the representative state. +template +void MergeStates(const Partition &partition, + MutableFst *fst) { + using StateId = typename Arc::StateId; + std::vector state_map(partition.NumClasses()); + for (StateId i = 0; i < partition.NumClasses(); ++i) { + PartitionIterator siter(partition, i); + state_map[i] = siter.Value(); // First state in partition. + } + // Relabels destination states. + for (StateId c = 0; c < partition.NumClasses(); ++c) { + for (PartitionIterator siter(partition, c); !siter.Done(); + siter.Next()) { + const auto s = siter.Value(); + for (MutableArcIterator> aiter(fst, s); !aiter.Done(); + aiter.Next()) { + auto arc = aiter.Value(); + arc.nextstate = state_map[partition.ClassId(arc.nextstate)]; + if (s == state_map[c]) { // For the first state, just sets destination. + aiter.SetValue(arc); + } else { + fst->AddArc(state_map[c], arc); + } + } + } + } + fst->SetStart(state_map[partition.ClassId(fst->Start())]); + Connect(fst); +} + +template +void AcceptorMinimize(MutableFst *fst, + bool allow_acyclic_minimization = true) { + if (!(fst->Properties(kAcceptor | kUnweighted, true) == + (kAcceptor | kUnweighted))) { + FSTERROR() << "FST is not an unweighted acceptor"; + fst->SetProperties(kError, kError); + return; + } + // Connects FST before minimization, handles disconnected states. + Connect(fst); + if (fst->NumStates() == 0) return; + if (allow_acyclic_minimization && fst->Properties(kAcyclic, true)) { + // Acyclic minimization (Revuz). + VLOG(2) << "Acyclic minimization"; + ArcSort(fst, ILabelCompare()); + AcyclicMinimizer minimizer(*fst); + MergeStates(minimizer.GetPartition(), fst); + } else { + // Either the FST has cycles, or it's generated from non-deterministic input + // (which the Revuz algorithm can't handle), so use the cyclic minimization + // algorithm of Hopcroft. + VLOG(2) << "Cyclic minimization"; + CyclicMinimizer> minimizer(*fst); + MergeStates(minimizer.GetPartition(), fst); + } + // Merges in appropriate semiring + ArcUniqueMapper mapper(*fst); + StateMap(fst, mapper); +} + +} // namespace internal + +// In place minimization of deterministic weighted automata and transducers, +// and also non-deterministic ones if they use an idempotent semiring. +// For transducers, if the 'sfst' argument is not null, the algorithm +// produces a compact factorization of the minimal transducer. +// +// In the acyclic deterministic case, we use an algorithm from Revuz that is +// linear in the number of arcs (edges) in the machine. +// +// In the cyclic or non-deterministic case, we use the classical Hopcroft +// minimization (which was presented for the deterministic case but which +// also works for non-deterministic FSTs); this has complexity O(e log v). +// +template +void Minimize(MutableFst *fst, MutableFst *sfst = nullptr, + float delta = kShortestDelta, bool allow_nondet = false) { + using Weight = typename Arc::Weight; + const auto props = fst->Properties( + kAcceptor | kIDeterministic | kWeighted | kUnweighted, true); + bool allow_acyclic_minimization; + if (props & kIDeterministic) { + allow_acyclic_minimization = true; + } else { + // Our approach to minimization of non-deterministic FSTs will only work in + // idempotent semirings---for non-deterministic inputs, a state could have + // multiple transitions to states that will get merged, and we'd have to + // sum their weights. The algorithm doesn't handle that. + if (!(Weight::Properties() & kIdempotent)) { + fst->SetProperties(kError, kError); + FSTERROR() << "Cannot minimize a non-deterministic FST over a " + "non-idempotent semiring"; + return; + } else if (!allow_nondet) { + fst->SetProperties(kError, kError); + FSTERROR() << "Refusing to minimize a non-deterministic FST with " + << "allow_nondet = false"; + return; + } + // The Revuz algorithm won't work for nondeterministic inputs, so if the + // input is nondeterministic, we'll have to pass a bool saying not to use + // that algorithm. We check at this level rather than in AcceptorMinimize(), + // because it's possible that the FST at this level could be deterministic, + // but a harmless type of non-determinism could be introduced by Encode() + // (thanks to kEncodeWeights, if the FST has epsilons and has a final + // weight with weights equal to some epsilon arc.) + allow_acyclic_minimization = false; + } + if (!(props & kAcceptor)) { // Weighted transducer. + VectorFst> gfst; + ArcMap(*fst, &gfst, ToGallicMapper()); + fst->DeleteStates(); + gfst.SetProperties(kAcceptor, kAcceptor); + Push(&gfst, REWEIGHT_TO_INITIAL, delta); + ArcMap(&gfst, QuantizeMapper>(delta)); + EncodeMapper> encoder( + kEncodeLabels | kEncodeWeights, ENCODE); + Encode(&gfst, &encoder); + internal::AcceptorMinimize(&gfst, allow_acyclic_minimization); + Decode(&gfst, encoder); + if (!sfst) { + FactorWeightFst, + GallicFactor> + fwfst(gfst); + std::unique_ptr osyms( + fst->OutputSymbols() ? fst->OutputSymbols()->Copy() : nullptr); + ArcMap(fwfst, fst, FromGallicMapper()); + fst->SetOutputSymbols(osyms.get()); + } else { + sfst->SetOutputSymbols(fst->OutputSymbols()); + GallicToNewSymbolsMapper mapper(sfst); + ArcMap(gfst, fst, &mapper); + fst->SetOutputSymbols(sfst->InputSymbols()); + } + } else if (props & kWeighted) { // Weighted acceptor. + Push(fst, REWEIGHT_TO_INITIAL, delta); + ArcMap(fst, QuantizeMapper(delta)); + EncodeMapper encoder(kEncodeLabels | kEncodeWeights, ENCODE); + Encode(fst, &encoder); + internal::AcceptorMinimize(fst, allow_acyclic_minimization); + Decode(fst, encoder); + } else { // Unweighted acceptor. + internal::AcceptorMinimize(fst, allow_acyclic_minimization); + } +} + +} // namespace fst + +#endif // FST_MINIMIZE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/mutable-fst.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/mutable-fst.h new file mode 100644 index 0000000000..cf15da9ada --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/mutable-fst.h @@ -0,0 +1,389 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Expanded FST augmented with mutators; interface class definition and +// mutable arc iterator interface. + +#ifndef FST_MUTABLE_FST_H_ +#define FST_MUTABLE_FST_H_ + +#include +#include + +#include +#include +#include +#include + +#include +#include + +#include + + +namespace fst { + +template +struct MutableArcIteratorData; + +// Abstract interface for an expanded FST which also supports mutation +// operations. To modify arcs, use MutableArcIterator. +template +class MutableFst : public ExpandedFst { + public: + using Arc = A; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + virtual MutableFst &operator=(const Fst &fst) = 0; + + MutableFst &operator=(const MutableFst &fst) { + return operator=(static_cast &>(fst)); + } + + // Sets the initial state. + virtual void SetStart(StateId) = 0; + + // Sets a state's final weight. + virtual void SetFinal(StateId, Weight) = 0; + + // Sets property bits w.r.t. mask. + virtual void SetProperties(uint64 props, uint64 mask) = 0; + + // Adds a state and returns its ID. + virtual StateId AddState() = 0; + + // Adds an arc to state. + virtual void AddArc(StateId, const Arc &arc) = 0; + + // Deletes some states, preserving original StateId ordering. + virtual void DeleteStates(const std::vector &) = 0; + + // Delete all states. + virtual void DeleteStates() = 0; + + // Delete some arcs at a given state. + virtual void DeleteArcs(StateId, size_t n) = 0; + + // Delete all arcs at a given state. + virtual void DeleteArcs(StateId) = 0; + + // Optional, best effort only. + virtual void ReserveStates(StateId n) {} + + // Optional, best effort only. + virtual void ReserveArcs(StateId s, size_t n) {} + + // Returns input label symbol table or nullptr if not specified. + const SymbolTable *InputSymbols() const override = 0; + + // Returns output label symbol table or nullptr if not specified. + const SymbolTable *OutputSymbols() const override = 0; + + // Returns input label symbol table or nullptr if not specified. + virtual SymbolTable *MutableInputSymbols() = 0; + + // Returns output label symbol table or nullptr if not specified. + virtual SymbolTable *MutableOutputSymbols() = 0; + + // Sets input label symbol table; pass nullptr to delete table. + virtual void SetInputSymbols(const SymbolTable *isyms) = 0; + + // Sets output label symbol table; pass nullptr to delete table. + virtual void SetOutputSymbols(const SymbolTable *osyms) = 0; + + // Gets a copy of this MutableFst. See Fst<>::Copy() for further doc. + MutableFst *Copy(bool safe = false) const override = 0; + + // Reads a MutableFst from an input stream, returning nullptr on error. + static MutableFst *Read(std::istream &strm, const FstReadOptions &opts) { + FstReadOptions ropts(opts); + FstHeader hdr; + if (ropts.header) { + hdr = *opts.header; + } else { + if (!hdr.Read(strm, opts.source)) return nullptr; + ropts.header = &hdr; + } + if (!(hdr.Properties() & kMutable)) { + LOG(ERROR) << "MutableFst::Read: Not a MutableFst: " << ropts.source; + return nullptr; + } + const auto &fst_type = hdr.FstType(); + const auto reader = FstRegister::GetRegister()->GetReader(fst_type); + if (!reader) { + LOG(ERROR) << "MutableFst::Read: Unknown FST type \"" << fst_type + << "\" (arc type = \"" << A::Type() << "\"): " << ropts.source; + return nullptr; + } + auto *fst = reader(strm, ropts); + if (!fst) return nullptr; + return static_cast *>(fst); + } + + // Reads a MutableFst from a file; returns nullptr on error. An empty + // filename results in reading from standard input. If convert is true, + // convert to a mutable FST subclass (given by convert_type) in the case + // that the input FST is non-mutable. + static MutableFst *Read(const string &filename, bool convert = false, + const string &convert_type = "vector") { + if (convert == false) { + if (!filename.empty()) { + std::ifstream strm(filename, + std::ios_base::in | std::ios_base::binary); + if (!strm) { + LOG(ERROR) << "MutableFst::Read: Can't open file: " << filename; + return nullptr; + } + return Read(strm, FstReadOptions(filename)); + } else { + return Read(std::cin, FstReadOptions("standard input")); + } + } else { // Converts to 'convert_type' if not mutable. + std::unique_ptr> ifst(Fst::Read(filename)); + if (!ifst) return nullptr; + if (ifst->Properties(kMutable, false)) { + return static_cast *>(ifst.release()); + } else { + std::unique_ptr> ofst(Convert(*ifst, convert_type)); + ifst.reset(); + if (!ofst) return nullptr; + if (!ofst->Properties(kMutable, false)) { + LOG(ERROR) << "MutableFst: Bad convert type: " << convert_type; + } + return static_cast *>(ofst.release()); + } + } + } + + // For generic mutuble arc iterator construction; not normally called + // directly by users. + virtual void InitMutableArcIterator(StateId s, + MutableArcIteratorData *data) = 0; +}; + +// Mutable arc iterator interface, templated on the Arc definition. This is +// used by mutable arc iterator specializations that are returned by the +// InitMutableArcIterator MutableFst method. +template +class MutableArcIteratorBase : public ArcIteratorBase { + public: + // Sets current arc. + virtual void SetValue(const Arc &) = 0; +}; + +template +struct MutableArcIteratorData { + MutableArcIteratorBase *base; // Specific iterator. +}; + +// Generic mutable arc iterator, templated on the FST definition; a wrapper +// around a pointer to a more specific one. +// +// Here is a typical use: +// +// for (MutableArcIterator aiter(&fst, s); +// !aiter.Done(); +// aiter.Next()) { +// StdArc arc = aiter.Value(); +// arc.ilabel = 7; +// aiter.SetValue(arc); +// ... +// } +// +// This version requires function calls. +template +class MutableArcIterator { + public: + using Arc = typename FST::Arc; + using StateId = typename Arc::StateId; + + MutableArcIterator(FST *fst, StateId s) { + fst->InitMutableArcIterator(s, &data_); + } + + ~MutableArcIterator() { delete data_.base; } + + bool Done() const { return data_.base->Done(); } + + const Arc &Value() const { return data_.base->Value(); } + + void Next() { data_.base->Next(); } + + size_t Position() const { return data_.base->Position(); } + + void Reset() { data_.base->Reset(); } + + void Seek(size_t a) { data_.base->Seek(a); } + + void SetValue(const Arc &arc) { data_.base->SetValue(arc); } + + uint32 Flags() const { return data_.base->Flags(); } + + void SetFlags(uint32 flags, uint32 mask) { + return data_.base->SetFlags(flags, mask); + } + + private: + MutableArcIteratorData data_; + + MutableArcIterator(const MutableArcIterator &) = delete; + MutableArcIterator &operator=(const MutableArcIterator &) = delete; +}; + +namespace internal { + +// MutableFst case: abstract methods. +template +inline typename Arc::Weight Final(const MutableFst &fst, + typename Arc::StateId s) { + return fst.Final(s); +} + +template +inline ssize_t NumArcs(const MutableFst &fst, typename Arc::StateId s) { + return fst.NumArcs(s); +} + +template +inline ssize_t NumInputEpsilons(const MutableFst &fst, + typename Arc::StateId s) { + return fst.NumInputEpsilons(s); +} + +template +inline ssize_t NumOutputEpsilons(const MutableFst &fst, + typename Arc::StateId s) { + return fst.NumOutputEpsilons(s); +} + +} // namespace internal + +// A useful alias when using StdArc. +using StdMutableFst = MutableFst; + +// This is a helper class template useful for attaching a MutableFst interface +// to its implementation, handling reference counting and COW semantics. +template > +class ImplToMutableFst : public ImplToExpandedFst { + public: + using Arc = typename Impl::Arc; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using ImplToExpandedFst::operator=; + + void SetStart(StateId s) override { + MutateCheck(); + GetMutableImpl()->SetStart(s); + } + + void SetFinal(StateId s, Weight weight) override { + MutateCheck(); + GetMutableImpl()->SetFinal(s, std::move(weight)); + } + + void SetProperties(uint64 props, uint64 mask) override { + // Can skip mutate check if extrinsic properties don't change, + // since it is then safe to update all (shallow) copies + const auto exprops = kExtrinsicProperties & mask; + if (GetImpl()->Properties(exprops) != (props & exprops)) MutateCheck(); + GetMutableImpl()->SetProperties(props, mask); + } + + StateId AddState() override { + MutateCheck(); + return GetMutableImpl()->AddState(); + } + + void AddArc(StateId s, const Arc &arc) override { + MutateCheck(); + GetMutableImpl()->AddArc(s, arc); + } + + void DeleteStates(const std::vector &dstates) override { + MutateCheck(); + GetMutableImpl()->DeleteStates(dstates); + } + + void DeleteStates() override { + if (!Unique()) { + const auto *isymbols = GetImpl()->InputSymbols(); + const auto *osymbols = GetImpl()->OutputSymbols(); + SetImpl(std::make_shared()); + GetMutableImpl()->SetInputSymbols(isymbols); + GetMutableImpl()->SetOutputSymbols(osymbols); + } else { + GetMutableImpl()->DeleteStates(); + } + } + + void DeleteArcs(StateId s, size_t n) override { + MutateCheck(); + GetMutableImpl()->DeleteArcs(s, n); + } + + void DeleteArcs(StateId s) override { + MutateCheck(); + GetMutableImpl()->DeleteArcs(s); + } + + void ReserveStates(StateId s) override { + MutateCheck(); + GetMutableImpl()->ReserveStates(s); + } + + void ReserveArcs(StateId s, size_t n) override { + MutateCheck(); + GetMutableImpl()->ReserveArcs(s, n); + } + + const SymbolTable *InputSymbols() const override { + return GetImpl()->InputSymbols(); + } + + const SymbolTable *OutputSymbols() const override { + return GetImpl()->OutputSymbols(); + } + + SymbolTable *MutableInputSymbols() override { + MutateCheck(); + return GetMutableImpl()->InputSymbols(); + } + + SymbolTable *MutableOutputSymbols() override { + MutateCheck(); + return GetMutableImpl()->OutputSymbols(); + } + + void SetInputSymbols(const SymbolTable *isyms) override { + MutateCheck(); + GetMutableImpl()->SetInputSymbols(isyms); + } + + void SetOutputSymbols(const SymbolTable *osyms) override { + MutateCheck(); + GetMutableImpl()->SetOutputSymbols(osyms); + } + + protected: + using ImplToExpandedFst::GetImpl; + using ImplToExpandedFst::GetMutableImpl; + using ImplToExpandedFst::Unique; + using ImplToExpandedFst::SetImpl; + using ImplToExpandedFst::InputSymbols; + + explicit ImplToMutableFst(std::shared_ptr impl) + : ImplToExpandedFst(impl) {} + + ImplToMutableFst(const ImplToMutableFst &fst, bool safe) + : ImplToExpandedFst(fst, safe) {} + + void MutateCheck() { + if (!Unique()) SetImpl(std::make_shared(*this)); + } +}; + +} // namespace fst + +#endif // FST_MUTABLE_FST_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/pair-weight.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/pair-weight.h new file mode 100644 index 0000000000..05ad15a4b2 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/pair-weight.h @@ -0,0 +1,164 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Pair weight templated base class for weight classes that contain two weights +// (e.g. Product, Lexicographic). + +#ifndef FST_PAIR_WEIGHT_H_ +#define FST_PAIR_WEIGHT_H_ + +#include +#include +#include +#include + +#include +#include + +#include + + +namespace fst { + +template +class PairWeight { + public: + using ReverseWeight = + PairWeight; + + PairWeight() {} + + PairWeight(const PairWeight &weight) + : value1_(weight.value1_), value2_(weight.value2_) {} + + PairWeight(W1 w1, W2 w2) : value1_(std::move(w1)), value2_(std::move(w2)) {} + + static const PairWeight &Zero() { + static const PairWeight zero(W1::Zero(), W2::Zero()); + return zero; + } + + static const PairWeight &One() { + static const PairWeight one(W1::One(), W2::One()); + return one; + } + + static const PairWeight &NoWeight() { + static const PairWeight no_weight(W1::NoWeight(), W2::NoWeight()); + return no_weight; + } + + std::istream &Read(std::istream &strm) { + value1_.Read(strm); + return value2_.Read(strm); + } + + std::ostream &Write(std::ostream &strm) const { + value1_.Write(strm); + return value2_.Write(strm); + } + + PairWeight &operator=(const PairWeight &weight) { + value1_ = weight.Value1(); + value2_ = weight.Value2(); + return *this; + } + + bool Member() const { return value1_.Member() && value2_.Member(); } + + size_t Hash() const { + const auto h1 = value1_.Hash(); + const auto h2 = value2_.Hash(); + static constexpr int lshift = 5; + static constexpr int rshift = CHAR_BIT * sizeof(size_t) - 5; + return h1 << lshift ^ h1 >> rshift ^ h2; + } + + PairWeight Quantize(float delta = kDelta) const { + return PairWeight(value1_.Quantize(delta), value2_.Quantize(delta)); + } + + ReverseWeight Reverse() const { + return ReverseWeight(value1_.Reverse(), value2_.Reverse()); + } + + const W1 &Value1() const { return value1_; } + + const W2 &Value2() const { return value2_; } + + void SetValue1(const W1 &weight) { value1_ = weight; } + + void SetValue2(const W2 &weight) { value2_ = weight; } + + private: + W1 value1_; + W2 value2_; +}; + +template +inline bool operator==(const PairWeight &w1, + const PairWeight &w2) { + return w1.Value1() == w2.Value1() && w1.Value2() == w2.Value2(); +} + +template +inline bool operator!=(const PairWeight &w1, + const PairWeight &w2) { + return w1.Value1() != w2.Value1() || w1.Value2() != w2.Value2(); +} + +template +inline bool ApproxEqual(const PairWeight &w1, + const PairWeight &w2, float delta = kDelta) { + return ApproxEqual(w1.Value1(), w2.Value1(), delta) && + ApproxEqual(w1.Value2(), w2.Value2(), delta); +} + +template +inline std::ostream &operator<<(std::ostream &strm, + const PairWeight &weight) { + CompositeWeightWriter writer(strm); + writer.WriteBegin(); + writer.WriteElement(weight.Value1()); + writer.WriteElement(weight.Value2()); + writer.WriteEnd(); + return strm; +} + +template +inline std::istream &operator>>(std::istream &strm, + PairWeight &weight) { + CompositeWeightReader reader(strm); + reader.ReadBegin(); + W1 w1; + reader.ReadElement(&w1); + weight.SetValue1(w1); + W2 w2; + reader.ReadElement(&w2, true); + weight.SetValue2(w2); + reader.ReadEnd(); + return strm; +} + +// This function object returns weights by calling the underlying generators +// and forming a pair. This is intended primarily for testing. +template +class WeightGenerate> { + public: + using Weight = PairWeight; + using Generate1 = WeightGenerate; + using Generate2 = WeightGenerate; + + explicit WeightGenerate(bool allow_zero = true) + : generate1_(allow_zero), generate2_(allow_zero) {} + + Weight operator()() const { return Weight(generate1_(), generate2_()); } + + private: + Generate1 generate1_; + Generate2 generate2_; +}; + +} // namespace fst + +#endif // FST_PAIR_WEIGHT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/partition.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/partition.h new file mode 100644 index 0000000000..5dbbe46a36 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/partition.h @@ -0,0 +1,305 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Functions and classes to create a partition of states. + +#ifndef FST_PARTITION_H_ +#define FST_PARTITION_H_ + +#include +#include + + +#include + + +namespace fst { +namespace internal { + +template +class PartitionIterator; + +// Defines a partitioning of elements, used to represent equivalence classes +// for FST operations like minimization. T must be a signed integer type. +// +// The elements are numbered from 0 to num_elements - 1. +// Initialize(num_elements) sets up the class for a given number of elements. +// We maintain a partition of these elements into classes. The classes are also +// numbered from zero; you can add a class with AddClass(), or add them in bulk +// with AllocateClasses(num_classes). Initially the elements are not assigned +// to any class; you set up the initial mapping from elements to classes by +// calling Add(element_id, class_id). You can also move an element to a +// different class by calling Move(element_id, class_id). +// +// We also support a rather specialized interface that allows you to efficiently +// split classes in the Hopcroft minimization algorithm. This maintains a +// binary partition of each class. Let's call these, rather arbitrarily, the +// 'yes' subset and the 'no' subset of each class, and assume that by default, +// each element of a class is in its 'no' subset. When one calls +// SplitOn(element_id), element_id is moved to the 'yes' subset of its class. +// (If it was already in the 'yes' set, it just stays there). The aim is to +// enable (later) splitting the class in two in time no greater than the time +// already spent calling SplitOn() for that class. We keep a list of the classes +// which have nonempty 'yes' sets, as visited_classes_. When one calls +// FinalizeSplit(Queue *l), for each class in visited_classes_ whose 'yes' +// and 'no' sets are both nonempty, it will create a new class consisting of +// the smaller of the two subsets (and this class will be added to the queue), +// and the old class will now be the larger of the two subsets. This call also +// resets all the yes/no partitions so that everything is in the 'no' subsets. +// +// One cannot use the Move() function if SplitOn() has been called without +// a subsequent call to FinalizeSplit() +template +class Partition { + public: + Partition() {} + + explicit Partition(T num_elements) { Initialize(num_elements); } + + // Creates an empty partition for num_elements. This means that the elements + // are not assigned to a class (i.e class_index = -1); you should set up the + // number of classes using AllocateClasses() or AddClass(), and allocate each + // element to a class by calling Add(element, class_id). + void Initialize(size_t num_elements) { + elements_.resize(num_elements); + classes_.reserve(num_elements); + classes_.clear(); + yes_counter_ = 1; + } + + // Adds a class; returns new number of classes. + T AddClass() { + auto num_classes = classes_.size(); + classes_.resize(num_classes + 1); + return num_classes; + } + + // Adds 'num_classes' new (empty) classes. + void AllocateClasses(T num_classes) { + classes_.resize(classes_.size() + num_classes); + } + + // Adds element_id to class_id. element_id should already have been allocated + // by calling Initialize(num_elements)---or the constructor taking + // num_elements---with num_elements > element_id. element_id must not + // currently be a member of any class; once elements have been added to a + // class, use the Move() method to move them from one class to another. + void Add(T element_id, T class_id) { + auto &this_element = elements_[element_id]; + auto &this_class = classes_[class_id]; + ++this_class.size; + // Adds the element to the 'no' subset of the class. + auto no_head = this_class.no_head; + if (no_head >= 0) elements_[no_head].prev_element = element_id; + this_class.no_head = element_id; + this_element.class_id = class_id; + // Adds to the 'no' subset of the class. + this_element.yes = 0; + this_element.next_element = no_head; + this_element.prev_element = -1; + } + + // Moves element_id from 'no' subset of its current class to 'no' subset of + // class class_id. This may not work correctly if you have called SplitOn() + // [for any element] and haven't subsequently called FinalizeSplit(). + void Move(T element_id, T class_id) { + auto elements = &(elements_[0]); + auto &element = elements[element_id]; + auto &old_class = classes_[element.class_id]; + --old_class.size; + // Excises the element from the 'no' list of its old class, where it is + // assumed to be. + if (element.prev_element >= 0) { + elements[element.prev_element].next_element = element.next_element; + } else { + old_class.no_head = element.next_element; + } + if (element.next_element >= 0) { + elements[element.next_element].prev_element = element.prev_element; + } + // Adds to new class. + Add(element_id, class_id); + } + + // Moves element_id to the 'yes' subset of its class if it was in the 'no' + // subset, and marks the class as having been visited. + void SplitOn(T element_id) { + auto elements = &(elements_[0]); + auto &element = elements[element_id]; + if (element.yes == yes_counter_) { + return; // Already in the 'yes' set; nothing to do. + } + auto class_id = element.class_id; + auto &this_class = classes_[class_id]; + // Excises the element from the 'no' list of its class. + if (element.prev_element >= 0) { + elements[element.prev_element].next_element = element.next_element; + } else { + this_class.no_head = element.next_element; + } + if (element.next_element >= 0) { + elements[element.next_element].prev_element = element.prev_element; + } + // Adds the element to the 'yes' list. + if (this_class.yes_head >= 0) { + elements[this_class.yes_head].prev_element = element_id; + } else { + visited_classes_.push_back(class_id); + } + element.yes = yes_counter_; + element.next_element = this_class.yes_head; + element.prev_element = -1; + this_class.yes_head = element_id; + this_class.yes_size++; + } + + // This should be called after one has possibly called SplitOn for one or more + // elements, thus moving those elements to the 'yes' subset for their class. + // For each class that has a nontrivial split (i.e., it's not the case that + // all members are in the 'yes' or 'no' subset), this function creates a new + // class containing the smaller of the two subsets of elements, leaving the + // larger group of elements in the old class. The identifier of the new class + // will be added to the queue provided as the pointer L. This method then + // moves all elements to the 'no' subset of their class. + template + void FinalizeSplit(Queue *queue) { + for (const auto &visited_class : visited_classes_) { + const auto new_class = SplitRefine(visited_class); + if (new_class != -1 && queue) queue->Enqueue(new_class); + } + visited_classes_.clear(); + // Incrementation sets all the 'yes' members of the elements to false. + ++yes_counter_; + } + + const T ClassId(T element_id) const { return elements_[element_id].class_id; } + + const size_t ClassSize(T class_id) const { return classes_[class_id].size; } + + const T NumClasses() const { return classes_.size(); } + + private: + friend class PartitionIterator; + + // Information about a given element. + struct Element { + T class_id; // Class ID of this element. + T yes; // This is to be interpreted as a bool, true if it's in the + // 'yes' set of this class. The interpretation as bool is + // (yes == yes_counter_ ? true : false). + T next_element; // Next element in the 'no' list or 'yes' list of this + // class, whichever of the two we belong to (think of + // this as the 'next' in a doubly-linked list, although + // it is an index into the elements array). Negative + // values corresponds to null. + T prev_element; // Previous element in the 'no' or 'yes' doubly linked + // list. Negative values corresponds to null. + }; + + // Information about a given class. + struct Class { + Class() : size(0), yes_size(0), no_head(-1), yes_head(-1) {} + T size; // Total number of elements in this class ('no' plus 'yes' + // subsets). + T yes_size; // Total number of elements of 'yes' subset of this class. + T no_head; // Index of head element of doubly-linked list in 'no' subset. + // Everything is in the 'no' subset until you call SplitOn(). + // -1 means no element. + T yes_head; // Index of head element of doubly-linked list in 'yes' subset. + // -1 means no element. + }; + + // This method, called from FinalizeSplit(), checks whether a class has to + // be split (a class will be split only if its 'yes' and 'no' subsets are + // both nonempty, but one can assume that since this function was called, the + // 'yes' subset is nonempty). It splits by taking the smaller subset and + // making it a new class, and leaving the larger subset of elements in the + // 'no' subset of the old class. It returns the new class if created, or -1 + // if none was created. + T SplitRefine(T class_id) { + auto yes_size = classes_[class_id].yes_size; + auto size = classes_[class_id].size; + auto no_size = size - yes_size; + if (no_size == 0) { + // All members are in the 'yes' subset, so we don't have to create a new + // class, just move them all to the 'no' subset. + classes_[class_id].no_head = classes_[class_id].yes_head; + classes_[class_id].yes_head = -1; + classes_[class_id].yes_size = 0; + return -1; + } else { + auto new_class_id = classes_.size(); + classes_.resize(classes_.size() + 1); + auto &old_class = classes_[class_id]; + auto &new_class = classes_[new_class_id]; + // The new_class will have the values from the constructor. + if (no_size < yes_size) { + // Moves the 'no' subset to new class ('no' subset). + new_class.no_head = old_class.no_head; + new_class.size = no_size; + // And makes the 'yes' subset of the old class ('no' subset). + old_class.no_head = old_class.yes_head; + old_class.yes_head = -1; + old_class.size = yes_size; + old_class.yes_size = 0; + } else { + // Moves the 'yes' subset to the new class (to the 'no' subset) + new_class.size = yes_size; + new_class.no_head = old_class.yes_head; + // Retains only the 'no' subset in the old class. + old_class.size = no_size; + old_class.yes_size = 0; + old_class.yes_head = -1; + } + auto elements = &(elements_[0]); + // Updates the 'class_id' of all the elements we moved. + for (auto e = new_class.no_head; e >= 0; e = elements[e].next_element) { + elements[e].class_id = new_class_id; + } + return new_class_id; + } + } + + // elements_[i] contains all info about the i'th element. + std::vector elements_; + // classes_[i] contains all info about the i'th class. + std::vector classes_; + // Set of visited classes to be used in split refine. + std::vector visited_classes_; + // yes_counter_ is used in interpreting the 'yes' members of class Element. + // If element.yes == yes_counter_, we interpret that element as being in the + // 'yes' subset of its class. This allows us to, in effect, set all those + // bools to false at a stroke by incrementing yes_counter_. + T yes_counter_; +}; + +// Iterates over members of the 'no' subset of a class in a partition. (When +// this is used, everything is in the 'no' subset). +template +class PartitionIterator { + public: + using Element = typename Partition::Element; + + PartitionIterator(const Partition &partition, T class_id) + : partition_(partition), + element_id_(partition_.classes_[class_id].no_head), + class_id_(class_id) {} + + bool Done() { return element_id_ < 0; } + + const T Value() { return element_id_; } + + void Next() { element_id_ = partition_.elements_[element_id_].next_element; } + + void Reset() { element_id_ = partition_.classes_[class_id_].no_head; } + + private: + const Partition &partition_; + T element_id_; + T class_id_; +}; + +} // namespace internal +} // namespace fst + +#endif // FST_PARTITION_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/power-weight.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/power-weight.h new file mode 100644 index 0000000000..f2f3cbdba0 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/power-weight.h @@ -0,0 +1,168 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Cartesian power weight semiring operation definitions. + +#ifndef FST_POWER_WEIGHT_H_ +#define FST_POWER_WEIGHT_H_ + +#include + +#include +#include + + +namespace fst { + +// Cartesian power semiring: W ^ n +// +// Forms: +// - a left semimodule when W is a left semiring, +// - a right semimodule when W is a right semiring, +// - a bisemimodule when W is a semiring, +// the free semimodule of rank n over W +// The Times operation is overloaded to provide the left and right scalar +// products. +template +class PowerWeight : public TupleWeight { + public: + using ReverseWeight = PowerWeight; + + PowerWeight() {} + + explicit PowerWeight(const TupleWeight &weight) + : TupleWeight(weight) {} + + template + PowerWeight(Iterator begin, Iterator end) : TupleWeight(begin, end) {} + + // Initialize component `index` to `weight`; initialize all other components + // to `default_weight` + PowerWeight(size_t index, const W &weight, + const W &default_weight = W::Zero()) + : TupleWeight(index, weight, default_weight) {} + + static const PowerWeight &Zero() { + static const PowerWeight zero(TupleWeight::Zero()); + return zero; + } + + static const PowerWeight &One() { + static const PowerWeight one(TupleWeight::One()); + return one; + } + + static const PowerWeight &NoWeight() { + static const PowerWeight no_weight(TupleWeight::NoWeight()); + return no_weight; + } + + static const string &Type() { + static const string *const type = + new string(W::Type() + "_^" + std::to_string(n)); + return *type; + } + + static constexpr uint64 Properties() { + return W::Properties() & + (kLeftSemiring | kRightSemiring | kCommutative | kIdempotent); + } + + PowerWeight Quantize(float delta = kDelta) const { + return PowerWeight(TupleWeight::Quantize(delta)); + } + + ReverseWeight Reverse() const { + return ReverseWeight(TupleWeight::Reverse()); + } +}; + +// Semiring plus operation. +template +inline PowerWeight Plus(const PowerWeight &w1, + const PowerWeight &w2) { + PowerWeight result; + for (size_t i = 0; i < n; ++i) { + result.SetValue(i, Plus(w1.Value(i), w2.Value(i))); + } + return result; +} + +// Semiring times operation. +template +inline PowerWeight Times(const PowerWeight &w1, + const PowerWeight &w2) { + PowerWeight result; + for (size_t i = 0; i < n; ++i) { + result.SetValue(i, Times(w1.Value(i), w2.Value(i))); + } + return result; +} + +// Semiring divide operation. +template +inline PowerWeight Divide(const PowerWeight &w1, + const PowerWeight &w2, + DivideType type = DIVIDE_ANY) { + PowerWeight result; + for (size_t i = 0; i < n; ++i) { + result.SetValue(i, Divide(w1.Value(i), w2.Value(i), type)); + } + return result; +} + +// Semimodule left scalar product. +template +inline PowerWeight Times(const W &scalar, + const PowerWeight &weight) { + PowerWeight result; + for (size_t i = 0; i < n; ++i) { + result.SetValue(i, Times(scalar, weight.Value(i))); + } + return result; +} + +// Semimodule right scalar product. +template +inline PowerWeight Times(const PowerWeight &weight, + const W &scalar) { + PowerWeight result; + for (size_t i = 0; i < n; ++i) { + result.SetValue(i, Times(weight.Value(i), scalar)); + } + return result; +} + +// Semimodule dot product. +template +inline W DotProduct(const PowerWeight &w1, const PowerWeight &w2) { + W result(W::Zero()); + for (size_t i = 0; i < n; ++i) { + result = Plus(result, Times(w1.Value(i), w2.Value(i))); + } + return result; +} + +// This function object generates weights over the Cartesian power of rank +// n over the underlying weight. This is intended primarily for testing. +template +class WeightGenerate> { + public: + using Weight = PowerWeight; + using Generate = WeightGenerate; + + explicit WeightGenerate(bool allow_zero = true) : generate_(allow_zero) {} + + Weight operator()() const { + Weight result; + for (size_t i = 0; i < n; ++i) result.SetValue(i, generate_()); + return result; + } + + private: + Generate generate_; +}; + +} // namespace fst + +#endif // FST_POWER_WEIGHT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/product-weight.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/product-weight.h new file mode 100644 index 0000000000..56a18be1ec --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/product-weight.h @@ -0,0 +1,107 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Product weight set and associated semiring operation definitions. + +#ifndef FST_PRODUCT_WEIGHT_H_ +#define FST_PRODUCT_WEIGHT_H_ + +#include +#include + +#include +#include + + +namespace fst { + +// Product semiring: W1 * W2. +template +class ProductWeight : public PairWeight { + public: + using ReverseWeight = + ProductWeight; + + ProductWeight() {} + + explicit ProductWeight(const PairWeight &weight) + : PairWeight(weight) {} + + ProductWeight(W1 w1, W2 w2) + : PairWeight(std::move(w1), std::move(w2)) {} + + static const ProductWeight &Zero() { + static const ProductWeight zero(PairWeight::Zero()); + return zero; + } + + static const ProductWeight &One() { + static const ProductWeight one(PairWeight::One()); + return one; + } + + static const ProductWeight &NoWeight() { + static const ProductWeight no_weight(PairWeight::NoWeight()); + return no_weight; + } + + static const string &Type() { + static const string *const type = + new string(W1::Type() + "_X_" + W2::Type()); + return *type; + } + + static constexpr uint64 Properties() { + return W1::Properties() & W2::Properties() & + (kLeftSemiring | kRightSemiring | kCommutative | kIdempotent); + } + + ProductWeight Quantize(float delta = kDelta) const { + return ProductWeight(PairWeight::Quantize(delta)); + } + + ReverseWeight Reverse() const { + return ReverseWeight(PairWeight::Reverse()); + } +}; + +template +inline ProductWeight Plus(const ProductWeight &w1, + const ProductWeight &w2) { + return ProductWeight(Plus(w1.Value1(), w2.Value1()), + Plus(w1.Value2(), w2.Value2())); +} + +template +inline ProductWeight Times(const ProductWeight &w1, + const ProductWeight &w2) { + return ProductWeight(Times(w1.Value1(), w2.Value1()), + Times(w1.Value2(), w2.Value2())); +} + +template +inline ProductWeight Divide(const ProductWeight &w1, + const ProductWeight &w2, + DivideType typ = DIVIDE_ANY) { + return ProductWeight(Divide(w1.Value1(), w2.Value1(), typ), + Divide(w1.Value2(), w2.Value2(), typ)); +} + +// This function object generates weights by calling the underlying generators +// for the template weight types, like all other pair weight types. This is +// intended primarily for testing. +template +class WeightGenerate> : + public WeightGenerate> { + public: + using Weight = ProductWeight; + using Generate = WeightGenerate>; + + explicit WeightGenerate(bool allow_zero = true) : Generate(allow_zero) {} + + Weight operator()() const { return Weight(Generate::operator()()); } +}; + +} // namespace fst + +#endif // FST_PRODUCT_WEIGHT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/project.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/project.h new file mode 100644 index 0000000000..63e8cd5858 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/project.h @@ -0,0 +1,159 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Functions and classes to project an FST on to its domain or range. + +#ifndef FST_PROJECT_H_ +#define FST_PROJECT_H_ + +#include +#include + + +namespace fst { + +// This specifies whether to project on input or output. +enum ProjectType { PROJECT_INPUT = 1, PROJECT_OUTPUT = 2 }; + +// Mapper to implement projection per arc. +template +class ProjectMapper { + public: + using FromArc = A; + using ToArc = A; + + explicit ProjectMapper(ProjectType project_type) + : project_type_(project_type) {} + + ToArc operator()(const FromArc &arc) const { + const auto label = project_type_ == PROJECT_INPUT ? arc.ilabel : arc.olabel; + return ToArc(label, label, arc.weight, arc.nextstate); + } + + constexpr MapFinalAction FinalAction() const { + return MAP_NO_SUPERFINAL; + } + + MapSymbolsAction InputSymbolsAction() const { + return project_type_ == PROJECT_INPUT ? MAP_COPY_SYMBOLS + : MAP_CLEAR_SYMBOLS; + } + + MapSymbolsAction OutputSymbolsAction() const { + return project_type_ == PROJECT_OUTPUT ? MAP_COPY_SYMBOLS + : MAP_CLEAR_SYMBOLS; + } + + uint64 Properties(uint64 props) const { + return ProjectProperties(props, project_type_ == PROJECT_INPUT); + } + + private: + const ProjectType project_type_; +}; + +// Projects an FST onto its domain or range by either copying each arcs' input +// label to the output label or vice versa. +// +// Complexity: +// +// Time: O(V + E) +// Space: O(1) +// +// where V is the number of states and E is the number of arcs. +template +inline void Project(const Fst &ifst, MutableFst *ofst, + ProjectType project_type) { + ArcMap(ifst, ofst, ProjectMapper(project_type)); + switch (project_type) { + case PROJECT_INPUT: + ofst->SetOutputSymbols(ifst.InputSymbols()); + return; + case PROJECT_OUTPUT: + ofst->SetInputSymbols(ifst.OutputSymbols()); + return; + } +} + +// Destructive variant of the above. +template +inline void Project(MutableFst *fst, ProjectType project_type) { + ArcMap(fst, ProjectMapper(project_type)); + switch (project_type) { + case PROJECT_INPUT: + fst->SetOutputSymbols(fst->InputSymbols()); + return; + case PROJECT_OUTPUT: + fst->SetInputSymbols(fst->OutputSymbols()); + return; + } +} + +// Projects an FST onto its domain or range by either copying each arc's input +// label to the output label or vice versa. This version is a delayed FST. +// +// Complexity: +// +// Time: O(v + e) +// Space: O(1) +// +// where v is the number of states visited and e is the number of arcs visited. +// Constant time and to visit an input state or arc is assumed and exclusive of +// caching. +template +class ProjectFst : public ArcMapFst> { + public: + using FromArc = A; + using ToArc = A; + + using Impl = internal::ArcMapFstImpl>; + + ProjectFst(const Fst &fst, ProjectType project_type) + : ArcMapFst>(fst, ProjectMapper(project_type)) { + if (project_type == PROJECT_INPUT) { + GetMutableImpl()->SetOutputSymbols(fst.InputSymbols()); + } + if (project_type == PROJECT_OUTPUT) { + GetMutableImpl()->SetInputSymbols(fst.OutputSymbols()); + } + } + + // See Fst<>::Copy() for doc. + ProjectFst(const ProjectFst &fst, bool safe = false) + : ArcMapFst>(fst, safe) {} + + // Gets a copy of this ProjectFst. See Fst<>::Copy() for further doc. + ProjectFst *Copy(bool safe = false) const override { + return new ProjectFst(*this, safe); + } + + private: + using ImplToFst::GetMutableImpl; +}; + +// Specialization for ProjectFst. +template +class StateIterator> + : public StateIterator>> { + public: + explicit StateIterator(const ProjectFst &fst) + : StateIterator>>(fst) {} +}; + +// Specialization for ProjectFst. +template +class ArcIterator> + : public ArcIterator>> { + public: + using StateId = typename A::StateId; + + ArcIterator(const ProjectFst &fst, StateId s) + : ArcIterator>>(fst, s) {} +}; + +// Useful alias when using StdArc. +using StdProjectFst = ProjectFst; + +} // namespace fst + +#endif // FST_PROJECT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/properties.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/properties.h new file mode 100644 index 0000000000..f97c9219f1 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/properties.h @@ -0,0 +1,468 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// FST property bits. + +#ifndef FST_PROPERTIES_H_ +#define FST_PROPERTIES_H_ + +#include +#include + +#include + +namespace fst { + +// The property bits here assert facts about an FST. If individual bits are +// added, then the composite properties below, the property functions and +// property names in properties.cc, and TestProperties() in test-properties.h +// should be updated. + +// BINARY PROPERTIES +// +// For each property below, there is a single bit. If it is set, the property is +// true. If it is not set, the property is false. + +// The Fst is an ExpandedFst. +constexpr uint64 kExpanded = 0x0000000000000001ULL; + +// The Fst is a MutableFst. +constexpr uint64 kMutable = 0x0000000000000002ULL; + +// An error was detected while constructing/using the FST. +constexpr uint64 kError = 0x0000000000000004ULL; + +// TRINARY PROPERTIES +// +// For each of these properties below there is a pair of property bits, one +// positive and one negative. If the positive bit is set, the property is true. +// If the negative bit is set, the property is false. If neither is set, the +// property has unknown value. Both should never be simultaneously set. The +// individual positive and negative bit pairs should be adjacent with the +// positive bit at an odd and lower position. + +// ilabel == olabel for each arc. +constexpr uint64 kAcceptor = 0x0000000000010000ULL; +// ilabel != olabel for some arc. +constexpr uint64 kNotAcceptor = 0x0000000000020000ULL; + +// ilabels unique leaving each state. +constexpr uint64 kIDeterministic = 0x0000000000040000ULL; +// ilabels not unique leaving some state. +constexpr uint64 kNonIDeterministic = 0x0000000000080000ULL; + +// olabels unique leaving each state. +constexpr uint64 kODeterministic = 0x0000000000100000ULL; +// olabels not unique leaving some state. +constexpr uint64 kNonODeterministic = 0x0000000000200000ULL; + +// FST has input/output epsilons. +constexpr uint64 kEpsilons = 0x0000000000400000ULL; +// FST has no input/output epsilons. +constexpr uint64 kNoEpsilons = 0x0000000000800000ULL; + +// FST has input epsilons. +constexpr uint64 kIEpsilons = 0x0000000001000000ULL; +// FST has no input epsilons. +constexpr uint64 kNoIEpsilons = 0x0000000002000000ULL; + +// FST has output epsilons. +constexpr uint64 kOEpsilons = 0x0000000004000000ULL; +// FST has no output epsilons. +constexpr uint64 kNoOEpsilons = 0x0000000008000000ULL; + +// ilabels sorted wrt < for each state. +constexpr uint64 kILabelSorted = 0x0000000010000000ULL; +// ilabels not sorted wrt < for some state. +constexpr uint64 kNotILabelSorted = 0x0000000020000000ULL; + +// olabels sorted wrt < for each state. +constexpr uint64 kOLabelSorted = 0x0000000040000000ULL; +// olabels not sorted wrt < for some state. +constexpr uint64 kNotOLabelSorted = 0x0000000080000000ULL; + +// Non-trivial arc or final weights. +constexpr uint64 kWeighted = 0x0000000100000000ULL; +// Only trivial arc and final weights. +constexpr uint64 kUnweighted = 0x0000000200000000ULL; + +// FST has cycles. +constexpr uint64 kCyclic = 0x0000000400000000ULL; +// FST has no cycles. +constexpr uint64 kAcyclic = 0x0000000800000000ULL; + +// FST has cycles containing the initial state. +constexpr uint64 kInitialCyclic = 0x0000001000000000ULL; +// FST has no cycles containing the initial state. +constexpr uint64 kInitialAcyclic = 0x0000002000000000ULL; + +// FST is topologically sorted. +constexpr uint64 kTopSorted = 0x0000004000000000ULL; +// FST is not topologically sorted. +constexpr uint64 kNotTopSorted = 0x0000008000000000ULL; + +// All states reachable from the initial state. +constexpr uint64 kAccessible = 0x0000010000000000ULL; +// Not all states reachable from the initial state. +constexpr uint64 kNotAccessible = 0x0000020000000000ULL; + +// All states can reach a final state. +constexpr uint64 kCoAccessible = 0x0000040000000000ULL; +// Not all states can reach a final state. +constexpr uint64 kNotCoAccessible = 0x0000080000000000ULL; + +// If NumStates() > 0, then state 0 is initial, state NumStates() - 1 is final, +// there is a transition from each non-final state i to state i + 1, and there +// are no other transitions. +constexpr uint64 kString = 0x0000100000000000ULL; + +// Not a string FST. +constexpr uint64 kNotString = 0x0000200000000000ULL; + +// FST has least one weighted cycle. +constexpr uint64 kWeightedCycles = 0x0000400000000000ULL; + +// Only unweighted cycles. +constexpr uint64 kUnweightedCycles = 0x0000800000000000ULL; + +// COMPOSITE PROPERTIES + +// Properties of an empty machine. +constexpr uint64 kNullProperties = + kAcceptor | kIDeterministic | kODeterministic | kNoEpsilons | kNoIEpsilons | + kNoOEpsilons | kILabelSorted | kOLabelSorted | kUnweighted | kAcyclic | + kInitialAcyclic | kTopSorted | kAccessible | kCoAccessible | kString | + kUnweightedCycles; + +// Properties that are preserved when an FST is copied. +constexpr uint64 kCopyProperties = + kError | kAcceptor | kNotAcceptor | kIDeterministic | kNonIDeterministic | + kODeterministic | kNonODeterministic | kEpsilons | kNoEpsilons | + kIEpsilons | kNoIEpsilons | kOEpsilons | kNoOEpsilons | kILabelSorted | + kNotILabelSorted | kOLabelSorted | kNotOLabelSorted | kWeighted | + kUnweighted | kCyclic | kAcyclic | kInitialCyclic | kInitialAcyclic | + kTopSorted | kNotTopSorted | kAccessible | kNotAccessible | kCoAccessible | + kNotCoAccessible | kString | kNotString | kWeightedCycles | + kUnweightedCycles; + +// Properties that are intrinsic to the FST. +constexpr uint64 kIntrinsicProperties = + kExpanded | kMutable | kAcceptor | kNotAcceptor | kIDeterministic | + kNonIDeterministic | kODeterministic | kNonODeterministic | kEpsilons | + kNoEpsilons | kIEpsilons | kNoIEpsilons | kOEpsilons | kNoOEpsilons | + kILabelSorted | kNotILabelSorted | kOLabelSorted | kNotOLabelSorted | + kWeighted | kUnweighted | kCyclic | kAcyclic | kInitialCyclic | + kInitialAcyclic | kTopSorted | kNotTopSorted | kAccessible | + kNotAccessible | kCoAccessible | kNotCoAccessible | kString | kNotString | + kWeightedCycles | kUnweightedCycles; + +// Properties that are (potentially) extrinsic to the FST. +constexpr uint64 kExtrinsicProperties = kError; + +// Properties that are preserved when an FST start state is set. +constexpr uint64 kSetStartProperties = + kExpanded | kMutable | kError | kAcceptor | kNotAcceptor | kIDeterministic | + kNonIDeterministic | kODeterministic | kNonODeterministic | kEpsilons | + kNoEpsilons | kIEpsilons | kNoIEpsilons | kOEpsilons | kNoOEpsilons | + kILabelSorted | kNotILabelSorted | kOLabelSorted | kNotOLabelSorted | + kWeighted | kUnweighted | kCyclic | kAcyclic | kTopSorted | kNotTopSorted | + kCoAccessible | kNotCoAccessible | kWeightedCycles | kUnweightedCycles; + +// Properties that are preserved when an FST final weight is set. +constexpr uint64 kSetFinalProperties = + kExpanded | kMutable | kError | kAcceptor | kNotAcceptor | kIDeterministic | + kNonIDeterministic | kODeterministic | kNonODeterministic | kEpsilons | + kNoEpsilons | kIEpsilons | kNoIEpsilons | kOEpsilons | kNoOEpsilons | + kILabelSorted | kNotILabelSorted | kOLabelSorted | kNotOLabelSorted | + kCyclic | kAcyclic | kInitialCyclic | kInitialAcyclic | kTopSorted | + kNotTopSorted | kAccessible | kNotAccessible | kWeightedCycles | + kUnweightedCycles; + +// Properties that are preserved when an FST state is added. +constexpr uint64 kAddStateProperties = + kExpanded | kMutable | kError | kAcceptor | kNotAcceptor | kIDeterministic | + kNonIDeterministic | kODeterministic | kNonODeterministic | kEpsilons | + kNoEpsilons | kIEpsilons | kNoIEpsilons | kOEpsilons | kNoOEpsilons | + kILabelSorted | kNotILabelSorted | kOLabelSorted | kNotOLabelSorted | + kWeighted | kUnweighted | kCyclic | kAcyclic | kInitialCyclic | + kInitialAcyclic | kTopSorted | kNotTopSorted | kNotAccessible | + kNotCoAccessible | kNotString | kWeightedCycles | kUnweightedCycles; + +// Properties that are preserved when an FST arc is added. +constexpr uint64 kAddArcProperties = + kExpanded | kMutable | kError | kNotAcceptor | kNonIDeterministic | + kNonODeterministic | kEpsilons | kIEpsilons | kOEpsilons | + kNotILabelSorted | kNotOLabelSorted | kWeighted | kCyclic | kInitialCyclic | + kNotTopSorted | kAccessible | kCoAccessible | kWeightedCycles; + +// Properties that are preserved when an FST arc is set. +constexpr uint64 kSetArcProperties = kExpanded | kMutable | kError; + +// Properties that are preserved when FST states are deleted. +constexpr uint64 kDeleteStatesProperties = + kExpanded | kMutable | kError | kAcceptor | kIDeterministic | + kODeterministic | kNoEpsilons | kNoIEpsilons | kNoOEpsilons | + kILabelSorted | kOLabelSorted | kUnweighted | kAcyclic | kInitialAcyclic | + kTopSorted | kUnweightedCycles; + +// Properties that are preserved when FST arcs are deleted. +constexpr uint64 kDeleteArcsProperties = + kExpanded | kMutable | kError | kAcceptor | kIDeterministic | + kODeterministic | kNoEpsilons | kNoIEpsilons | kNoOEpsilons | + kILabelSorted | kOLabelSorted | kUnweighted | kAcyclic | kInitialAcyclic | + kTopSorted | kNotAccessible | kNotCoAccessible | kUnweightedCycles; + +// Properties that are preserved when an FST's states are reordered. +constexpr uint64 kStateSortProperties = + kExpanded | kMutable | kError | kAcceptor | kNotAcceptor | kIDeterministic | + kNonIDeterministic | kODeterministic | kNonODeterministic | kEpsilons | + kNoEpsilons | kIEpsilons | kNoIEpsilons | kOEpsilons | kNoOEpsilons | + kILabelSorted | kNotILabelSorted | kOLabelSorted | kNotOLabelSorted | + kWeighted | kUnweighted | kCyclic | kAcyclic | kInitialCyclic | + kInitialAcyclic | kAccessible | kNotAccessible | kCoAccessible | + kNotCoAccessible | kWeightedCycles | kUnweightedCycles; + +// Properties that are preserved when an FST's arcs are reordered. +constexpr uint64 kArcSortProperties = + kExpanded | kMutable | kError | kAcceptor | kNotAcceptor | kIDeterministic | + kNonIDeterministic | kODeterministic | kNonODeterministic | kEpsilons | + kNoEpsilons | kIEpsilons | kNoIEpsilons | kOEpsilons | kNoOEpsilons | + kWeighted | kUnweighted | kCyclic | kAcyclic | kInitialCyclic | + kInitialAcyclic | kTopSorted | kNotTopSorted | kAccessible | + kNotAccessible | kCoAccessible | kNotCoAccessible | kString | kNotString | + kWeightedCycles | kUnweightedCycles; + +// Properties that are preserved when an FST's input labels are changed. +constexpr uint64 kILabelInvariantProperties = + kExpanded | kMutable | kError | kODeterministic | kNonODeterministic | + kOEpsilons | kNoOEpsilons | kOLabelSorted | kNotOLabelSorted | kWeighted | + kUnweighted | kCyclic | kAcyclic | kInitialCyclic | kInitialAcyclic | + kTopSorted | kNotTopSorted | kAccessible | kNotAccessible | kCoAccessible | + kNotCoAccessible | kString | kNotString | kWeightedCycles | + kUnweightedCycles; + +// Properties that are preserved when an FST's output labels are changed. +constexpr uint64 kOLabelInvariantProperties = + kExpanded | kMutable | kError | kIDeterministic | kNonIDeterministic | + kIEpsilons | kNoIEpsilons | kILabelSorted | kNotILabelSorted | kWeighted | + kUnweighted | kCyclic | kAcyclic | kInitialCyclic | kInitialAcyclic | + kTopSorted | kNotTopSorted | kAccessible | kNotAccessible | kCoAccessible | + kNotCoAccessible | kString | kNotString | kWeightedCycles | + kUnweightedCycles; + +// Properties that are preserved when an FST's weights are changed. This +// assumes that the set of states that are non-final is not changed. +constexpr uint64 kWeightInvariantProperties = + kExpanded | kMutable | kError | kAcceptor | kNotAcceptor | kIDeterministic | + kNonIDeterministic | kODeterministic | kNonODeterministic | kEpsilons | + kNoEpsilons | kIEpsilons | kNoIEpsilons | kOEpsilons | kNoOEpsilons | + kILabelSorted | kNotILabelSorted | kOLabelSorted | kNotOLabelSorted | + kCyclic | kAcyclic | kInitialCyclic | kInitialAcyclic | kTopSorted | + kNotTopSorted | kAccessible | kNotAccessible | kCoAccessible | + kNotCoAccessible | kString | kNotString; + +// Properties that are preserved when a superfinal state is added and an FST's +// final weights are directed to it via new transitions. +constexpr uint64 kAddSuperFinalProperties = + kExpanded | kMutable | kError | kAcceptor | kNotAcceptor | + kNonIDeterministic | kNonODeterministic | kEpsilons | kIEpsilons | + kOEpsilons | kNotILabelSorted | kNotOLabelSorted | kWeighted | kUnweighted | + kCyclic | kAcyclic | kInitialCyclic | kInitialAcyclic | kNotTopSorted | + kNotAccessible | kCoAccessible | kNotCoAccessible | kNotString | + kWeightedCycles | kUnweightedCycles; + +// Properties that are preserved when a superfinal state is removed and the +// epsilon transitions directed to it are made final weights. +constexpr uint64 kRmSuperFinalProperties = + kExpanded | kMutable | kError | kAcceptor | kNotAcceptor | kIDeterministic | + kODeterministic | kNoEpsilons | kNoIEpsilons | kNoOEpsilons | + kILabelSorted | kOLabelSorted | kWeighted | kUnweighted | kCyclic | + kAcyclic | kInitialCyclic | kInitialAcyclic | kTopSorted | kAccessible | + kCoAccessible | kNotCoAccessible | kString | kWeightedCycles | + kUnweightedCycles; + +// All binary properties. +constexpr uint64 kBinaryProperties = 0x0000000000000007ULL; + +// All trinary properties. +constexpr uint64 kTrinaryProperties = 0x0000ffffffff0000ULL; + +// COMPUTED PROPERTIES + +// 1st bit of trinary properties. +constexpr uint64 kPosTrinaryProperties = kTrinaryProperties & + 0x5555555555555555ULL; + +// 2nd bit of trinary properties. +constexpr uint64 kNegTrinaryProperties = kTrinaryProperties & + 0xaaaaaaaaaaaaaaaaULL; + +// All properties. +constexpr uint64 kFstProperties = kBinaryProperties | kTrinaryProperties; + +// PROPERTY FUNCTIONS and STRING NAMES (defined in properties.cc). + +// Below are functions for getting property bit vectors when executing +// mutation operations. +inline uint64 SetStartProperties(uint64 inprops); + +template +uint64 SetFinalProperties(uint64 inprops, const Weight &old_weight, + const Weight &new_weight); + +inline uint64 AddStateProperties(uint64 inprops); + +template +uint64 AddArcProperties(uint64 inprops, typename A::StateId s, const A &arc, + const A *prev_arc); + +inline uint64 DeleteStatesProperties(uint64 inprops); + +inline uint64 DeleteAllStatesProperties(uint64 inprops, uint64 staticProps); + +inline uint64 DeleteArcsProperties(uint64 inprops); + +uint64 ClosureProperties(uint64 inprops, bool star, bool delayed = false); + +uint64 ComplementProperties(uint64 inprops); + +uint64 ComposeProperties(uint64 inprops1, uint64 inprops2); + +uint64 ConcatProperties(uint64 inprops1, uint64 inprops2, bool delayed = false); + +uint64 DeterminizeProperties(uint64 inprops, bool has_subsequential_label, + bool distinct_psubsequential_labels); + +uint64 FactorWeightProperties(uint64 inprops); + +uint64 InvertProperties(uint64 inprops); + +uint64 ProjectProperties(uint64 inprops, bool project_input); + +uint64 RandGenProperties(uint64 inprops, bool weighted); + +uint64 RelabelProperties(uint64 inprops); + +uint64 ReplaceProperties(const std::vector &inprops, ssize_t root, + bool epsilon_on_call, bool epsilon_on_return, + bool out_epsilon_on_call, bool out_epsilon_on_return, + bool replace_transducer, bool no_empty_fst, + bool all_ilabel_sorted, bool all_olabel_sorted, + bool all_negative_or_dense); + +uint64 ReverseProperties(uint64 inprops, bool has_superinitial); + +uint64 ReweightProperties(uint64 inprops); + +uint64 RmEpsilonProperties(uint64 inprops, bool delayed = false); + +uint64 ShortestPathProperties(uint64 props, bool tree = false); + +uint64 SynchronizeProperties(uint64 inprops); + +uint64 UnionProperties(uint64 inprops1, uint64 inprops2, bool delayed = false); + +// Definitions of inlined functions. + +uint64 SetStartProperties(uint64 inprops) { + auto outprops = inprops & kSetStartProperties; + if (inprops & kAcyclic) { + outprops |= kInitialAcyclic; + } + return outprops; +} + +uint64 AddStateProperties(uint64 inprops) { + return inprops & kAddStateProperties; +} + +uint64 DeleteStatesProperties(uint64 inprops) { + return inprops & kDeleteStatesProperties; +} + +uint64 DeleteAllStatesProperties(uint64 inprops, uint64 staticprops) { + const auto outprops = inprops & kError; + return outprops | kNullProperties | staticprops; +} + +uint64 DeleteArcsProperties(uint64 inprops) { + return inprops & kDeleteArcsProperties; +} + +// Definitions of template functions. + +template +uint64 SetFinalProperties(uint64 inprops, const Weight &old_weight, + const Weight &new_weight) { + auto outprops = inprops; + if (old_weight != Weight::Zero() && old_weight != Weight::One()) { + outprops &= ~kWeighted; + } + if (new_weight != Weight::Zero() && new_weight != Weight::One()) { + outprops |= kWeighted; + outprops &= ~kUnweighted; + } + outprops &= kSetFinalProperties | kWeighted | kUnweighted; + return outprops; +} + +/// Gets the properties for the MutableFst::AddArc method. +/// +/// \param inprops the current properties of the FST +/// \param s the ID of the state to which an arc is being added. +/// \param arc the arc being added to the state with the specified ID +/// \param prev_arc the previously-added (or "last") arc of state s, or nullptr +// if s currently has no arcs. +template +uint64 AddArcProperties(uint64 inprops, typename Arc::StateId s, + const Arc &arc, const Arc *prev_arc) { + using Weight = typename Arc::Weight; + auto outprops = inprops; + if (arc.ilabel != arc.olabel) { + outprops |= kNotAcceptor; + outprops &= ~kAcceptor; + } + if (arc.ilabel == 0) { + outprops |= kIEpsilons; + outprops &= ~kNoIEpsilons; + if (arc.olabel == 0) { + outprops |= kEpsilons; + outprops &= ~kNoEpsilons; + } + } + if (arc.olabel == 0) { + outprops |= kOEpsilons; + outprops &= ~kNoOEpsilons; + } + if (prev_arc) { + if (prev_arc->ilabel > arc.ilabel) { + outprops |= kNotILabelSorted; + outprops &= ~kILabelSorted; + } + if (prev_arc->olabel > arc.olabel) { + outprops |= kNotOLabelSorted; + outprops &= ~kOLabelSorted; + } + } + if (arc.weight != Weight::Zero() && arc.weight != Weight::One()) { + outprops |= kWeighted; + outprops &= ~kUnweighted; + } + if (arc.nextstate <= s) { + outprops |= kNotTopSorted; + outprops &= ~kTopSorted; + } + outprops &= kAddArcProperties | kAcceptor | kNoEpsilons | kNoIEpsilons | + kNoOEpsilons | kILabelSorted | kOLabelSorted | kUnweighted | + kTopSorted; + if (outprops & kTopSorted) { + outprops |= kAcyclic | kInitialAcyclic; + } + return outprops; +} + +extern const char *PropertyNames[]; + +} // namespace fst + +#endif // FST_PROPERTIES_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/prune.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/prune.h new file mode 100644 index 0000000000..b9b888f434 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/prune.h @@ -0,0 +1,336 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Functions implementing pruning. + +#ifndef FST_PRUNE_H_ +#define FST_PRUNE_H_ + +#include +#include +#include + +#include + +#include +#include +#include + + +namespace fst { +namespace internal { + +template +class PruneCompare { + public: + PruneCompare(const std::vector &idistance, + const std::vector &fdistance) + : idistance_(idistance), fdistance_(fdistance) {} + + bool operator()(const StateId x, const StateId y) const { + const auto wx = Times(IDistance(x), FDistance(x)); + const auto wy = Times(IDistance(y), FDistance(y)); + return less_(wx, wy); + } + + private: + Weight IDistance(const StateId s) const { + return s < idistance_.size() ? idistance_[s] : Weight::Zero(); + } + + Weight FDistance(const StateId s) const { + return s < fdistance_.size() ? fdistance_[s] : Weight::Zero(); + } + + const std::vector &idistance_; + const std::vector &fdistance_; + NaturalLess less_; +}; + +} // namespace internal + +template +struct PruneOptions { + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + PruneOptions(const Weight &weight_threshold, StateId state_threshold, + ArcFilter filter, std::vector *distance = nullptr, + float delta = kDelta, bool threshold_initial = false) + : weight_threshold(std::move(weight_threshold)), + state_threshold(state_threshold), + filter(std::move(filter)), + distance(distance), + delta(delta), + threshold_initial(threshold_initial) {} + + // Pruning weight threshold. + Weight weight_threshold; + // Pruning state threshold. + StateId state_threshold; + // Arc filter. + ArcFilter filter; + // If non-zero, passes in pre-computed shortest distance to final states. + const std::vector *distance; + // Determines the degree of convergence required when computing shortest + // distances. + float delta; + // Determines if the shortest path weight is left (true) or right + // (false) multiplied by the threshold to get the limit for + // keeping a state or arc (matters if the semiring is not + // commutative). + bool threshold_initial; +}; + +// Pruning algorithm: this version modifies its input and it takes an options +// class as an argument. After pruning the FST contains states and arcs that +// belong to a successful path in the FST whose weight is no more than the +// weight of the shortest path Times() the provided weight threshold. When the +// state threshold is not kNoStateId, the output FST is further restricted to +// have no more than the number of states in opts.state_threshold. Weights must +// have the path property. The weight of any cycle needs to be bounded; i.e., +// +// Plus(weight, Weight::One()) == Weight::One() +template ::type * = nullptr> +void Prune(MutableFst *fst, const PruneOptions &opts) { + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + using StateHeap = Heap>; + auto ns = fst->NumStates(); + if (ns < 1) return; + std::vector idistance(ns, Weight::Zero()); + std::vector tmp; + if (!opts.distance) { + tmp.reserve(ns); + ShortestDistance(*fst, &tmp, true, opts.delta); + } + const auto *fdistance = opts.distance ? opts.distance : &tmp; + if ((opts.state_threshold == 0) || (fdistance->size() <= fst->Start()) || + ((*fdistance)[fst->Start()] == Weight::Zero())) { + fst->DeleteStates(); + return; + } + internal::PruneCompare compare(idistance, *fdistance); + StateHeap heap(compare); + std::vector visited(ns, false); + std::vector enqueued(ns, StateHeap::kNoKey); + std::vector dead; + dead.push_back(fst->AddState()); + NaturalLess less; + auto s = fst->Start(); + const auto limit = opts.threshold_initial ? + Times(opts.weight_threshold, (*fdistance)[s]) : + Times((*fdistance)[s], opts.weight_threshold); + StateId num_visited = 0; + + if (!less(limit, (*fdistance)[s])) { + idistance[s] = Weight::One(); + enqueued[s] = heap.Insert(s); + ++num_visited; + } + while (!heap.Empty()) { + s = heap.Top(); + heap.Pop(); + enqueued[s] = StateHeap::kNoKey; + visited[s] = true; + if (less(limit, Times(idistance[s], fst->Final(s)))) { + fst->SetFinal(s, Weight::Zero()); + } + for (MutableArcIterator> aiter(fst, s); !aiter.Done(); + aiter.Next()) { + auto arc = aiter.Value(); // Copy intended. + if (!opts.filter(arc)) continue; + const auto weight = Times(Times(idistance[s], arc.weight), + arc.nextstate < fdistance->size() ? + (*fdistance)[arc.nextstate] : Weight::Zero()); + if (less(limit, weight)) { + arc.nextstate = dead[0]; + aiter.SetValue(arc); + continue; + } + if (less(Times(idistance[s], arc.weight), idistance[arc.nextstate])) { + idistance[arc.nextstate] = Times(idistance[s], arc.weight); + } + if (visited[arc.nextstate]) continue; + if ((opts.state_threshold != kNoStateId) && + (num_visited >= opts.state_threshold)) { + continue; + } + if (enqueued[arc.nextstate] == StateHeap::kNoKey) { + enqueued[arc.nextstate] = heap.Insert(arc.nextstate); + ++num_visited; + } else { + heap.Update(enqueued[arc.nextstate], arc.nextstate); + } + } + } + for (StateId i = 0; i < visited.size(); ++i) { + if (!visited[i]) dead.push_back(i); + } + fst->DeleteStates(dead); +} + +template ::type * = nullptr> +void Prune(MutableFst *fst, const PruneOptions &) { + FSTERROR() << "Prune: Weight needs to have the path property: " + << Arc::Weight::Type(); + fst->SetProperties(kError, kError); +} + +// Pruning algorithm: this version modifies its input and takes the +// pruning threshold as an argument. It deletes states and arcs in the +// FST that do not belong to a successful path whose weight is more +// than the weight of the shortest path Times() the provided weight +// threshold. When the state threshold is not kNoStateId, the output +// FST is further restricted to have no more than the number of states +// in opts.state_threshold. Weights must have the path property. The +// weight of any cycle needs to be bounded; i.e., +// +// Plus(weight, Weight::One()) == Weight::One() +template +void Prune(MutableFst *fst, typename Arc::Weight weight_threshold, + typename Arc::StateId state_threshold = kNoStateId, + float delta = kDelta) { + const PruneOptions> opts( + weight_threshold, state_threshold, AnyArcFilter(), nullptr, delta); + Prune(fst, opts); +} + +// Pruning algorithm: this version writes the pruned input FST to an +// output MutableFst and it takes an options class as an argument. The +// output FST contains states and arcs that belong to a successful +// path in the input FST whose weight is more than the weight of the +// shortest path Times() the provided weight threshold. When the state +// threshold is not kNoStateId, the output FST is further restricted +// to have no more than the number of states in +// opts.state_threshold. Weights have the path property. The weight +// of any cycle needs to be bounded; i.e., +// +// Plus(weight, Weight::One()) == Weight::One() +template ::value>::type * = + nullptr> +void Prune(const Fst &ifst, MutableFst *ofst, + const PruneOptions &opts) { + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + using StateHeap = Heap>; + ofst->DeleteStates(); + ofst->SetInputSymbols(ifst.InputSymbols()); + ofst->SetOutputSymbols(ifst.OutputSymbols()); + if (ifst.Start() == kNoStateId) return; + NaturalLess less; + if (less(opts.weight_threshold, Weight::One()) || + (opts.state_threshold == 0)) { + return; + } + std::vector idistance; + std::vector tmp; + if (!opts.distance) ShortestDistance(ifst, &tmp, true, opts.delta); + const auto *fdistance = opts.distance ? opts.distance : &tmp; + if ((fdistance->size() <= ifst.Start()) || + ((*fdistance)[ifst.Start()] == Weight::Zero())) { + return; + } + internal::PruneCompare compare(idistance, *fdistance); + StateHeap heap(compare); + std::vector copy; + std::vector enqueued; + std::vector visited; + auto s = ifst.Start(); + const auto limit = opts.threshold_initial ? + Times(opts.weight_threshold, (*fdistance)[s]) : + Times((*fdistance)[s], opts.weight_threshold); + while (copy.size() <= s) copy.push_back(kNoStateId); + copy[s] = ofst->AddState(); + ofst->SetStart(copy[s]); + while (idistance.size() <= s) idistance.push_back(Weight::Zero()); + idistance[s] = Weight::One(); + while (enqueued.size() <= s) { + enqueued.push_back(StateHeap::kNoKey); + visited.push_back(false); + } + enqueued[s] = heap.Insert(s); + while (!heap.Empty()) { + s = heap.Top(); + heap.Pop(); + enqueued[s] = StateHeap::kNoKey; + visited[s] = true; + if (!less(limit, Times(idistance[s], ifst.Final(s)))) { + ofst->SetFinal(copy[s], ifst.Final(s)); + } + for (ArcIterator> aiter(ifst, s); !aiter.Done(); aiter.Next()) { + const auto &arc = aiter.Value(); + if (!opts.filter(arc)) continue; + const auto weight = Times(Times(idistance[s], arc.weight), + arc.nextstate < fdistance->size() ? + (*fdistance)[arc.nextstate] : Weight::Zero()); + if (less(limit, weight)) continue; + if ((opts.state_threshold != kNoStateId) && + (ofst->NumStates() >= opts.state_threshold)) { + continue; + } + while (idistance.size() <= arc.nextstate) { + idistance.push_back(Weight::Zero()); + } + if (less(Times(idistance[s], arc.weight), idistance[arc.nextstate])) { + idistance[arc.nextstate] = Times(idistance[s], arc.weight); + } + while (copy.size() <= arc.nextstate) copy.push_back(kNoStateId); + if (copy[arc.nextstate] == kNoStateId) { + copy[arc.nextstate] = ofst->AddState(); + } + ofst->AddArc(copy[s], Arc(arc.ilabel, arc.olabel, arc.weight, + copy[arc.nextstate])); + while (enqueued.size() <= arc.nextstate) { + enqueued.push_back(StateHeap::kNoKey); + visited.push_back(false); + } + if (visited[arc.nextstate]) continue; + if (enqueued[arc.nextstate] == StateHeap::kNoKey) { + enqueued[arc.nextstate] = heap.Insert(arc.nextstate); + } else { + heap.Update(enqueued[arc.nextstate], arc.nextstate); + } + } + } +} + +template ::value>::type + * = nullptr> +void Prune(const Fst &, MutableFst *ofst, + const PruneOptions &) { + FSTERROR() << "Prune: Weight needs to have the path property: " + << Arc::Weight::Type(); + ofst->SetProperties(kError, kError); +} + +// Pruning algorithm: this version writes the pruned input FST to an +// output MutableFst and simply takes the pruning threshold as an +// argument. The output FST contains states and arcs that belong to a +// successful path in the input FST whose weight is no more than the +// weight of the shortest path Times() the provided weight +// threshold. When the state threshold is not kNoStateId, the output +// FST is further restricted to have no more than the number of states +// in opts.state_threshold. Weights must have the path property. The +// weight of any cycle needs to be bounded; i.e., +// +// Plus(weight, Weight::One()) = Weight::One(); +template +void Prune(const Fst &ifst, MutableFst *ofst, + typename Arc::Weight weight_threshold, + typename Arc::StateId state_threshold = kNoStateId, + float delta = kDelta) { + const PruneOptions> opts( + weight_threshold, state_threshold, AnyArcFilter(), nullptr, delta); + Prune(ifst, ofst, opts); +} + +} // namespace fst + +#endif // FST_PRUNE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/push.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/push.h new file mode 100644 index 0000000000..1f77273927 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/push.h @@ -0,0 +1,155 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Class to reweight/push an FST, and utility functions to weigh and reweight +// an FST. + +#ifndef FST_PUSH_H_ +#define FST_PUSH_H_ + +#include + +#include + +#include +#include +#include +#include +#include + + +namespace fst { + +// Computes the total weight (sum of the weights of all accepting paths) from +// the output of ShortestDistance, using the shortest distance from the final +// state when reverse is true and from the initial state otherwise. +template +typename Arc::Weight ComputeTotalWeight( + const Fst &fst, const std::vector &distance, + bool reverse) { + if (reverse) { + return fst.Start() < distance.size() ? distance[fst.Start()] + : Arc::Weight::Zero(); + } + auto sum = Arc::Weight::Zero(); + for (typename Arc::StateId s = 0; s < distance.size(); ++s) { + sum = Plus(sum, Times(distance[s], fst.Final(s))); + } + return sum; +} + +// Divides the weight of every accepting path by a fixed weight. This weight +// is also divided at the final state if at_final is true and at the initial +// state otherwise. +template +void RemoveWeight(MutableFst *fst, const typename Arc::Weight &weight, + bool at_final) { + using Weight = typename Arc::Weight; + if ((weight == Weight::One()) || (weight == Weight::Zero())) return; + if (at_final) { + for (StateIterator> siter(*fst); !siter.Done(); + siter.Next()) { + fst->SetFinal(siter.Value(), + Divide(fst->Final(siter.Value()), weight, DIVIDE_RIGHT)); + } + } else { + const auto start = fst->Start(); + for (MutableArcIterator> aiter(fst, start); !aiter.Done(); + aiter.Next()) { + auto arc = aiter.Value(); + arc.weight = Divide(arc.weight, weight, DIVIDE_LEFT); + aiter.SetValue(arc); + } + fst->SetFinal(start, Divide(fst->Final(start), weight, DIVIDE_LEFT)); + } +} + +// Pushes the weights in FST in the direction defined by TYPE. If +// pushing towards the initial state, the sum of the weight of the +// outgoing transitions and final weight at a non-initial state is +// equal to One() in the resulting machine. If pushing towards the +// final state, the same property holds on the reverse machine. +// +// Weight needs to be left distributive when pushing towards the +// initial state and right distributive when pushing towards the final +// states. +template +void Push(MutableFst *fst, ReweightType type, float delta = kDelta, + bool remove_total_weight = false) { + using Weight = typename Arc::Weight; + std::vector distance; + ShortestDistance(*fst, &distance, type == REWEIGHT_TO_INITIAL, delta); + auto total_weight = Weight::One(); + if (remove_total_weight) { + total_weight = + ComputeTotalWeight(*fst, distance, type == REWEIGHT_TO_INITIAL); + } + Reweight(fst, distance, type); + if (remove_total_weight) { + RemoveWeight(fst, total_weight, type == REWEIGHT_TO_FINAL); + } +} + +constexpr uint32 kPushWeights = 0x0001; +constexpr uint32 kPushLabels = 0x0002; +constexpr uint32 kPushRemoveTotalWeight = 0x0004; +constexpr uint32 kPushRemoveCommonAffix = 0x0008; + +// Pushes the weights and/or labels of the input FST into the output +// mutable FST by pushing weights and/or labels (as determined by the +// ptype argument) towards the initial state or final states (as +// determined by the rtype template parameter). The weight type must +// be left distributive when pushing weights towards the initial state, and +// right distribution when pushing weights towards the final states. +template +void Push(const Fst &ifst, MutableFst *ofst, uint32 ptype, + float delta = kDelta) { + using Label = typename Arc::Label; + using Weight = typename Arc::Weight; + if ((ptype & (kPushWeights | kPushLabels)) == kPushWeights) { + *ofst = ifst; + Push(ofst, rtype, delta, ptype & kPushRemoveTotalWeight); + } else if (ptype & kPushLabels) { + const auto gtype = + rtype == REWEIGHT_TO_INITIAL ? GALLIC_LEFT : GALLIC_RIGHT; + using GallicWeight = typename GallicArc::Weight; + std::vector gdistance; + VectorFst> gfst; + ArcMap(ifst, &gfst, ToGallicMapper()); + if (ptype & kPushWeights) { + ShortestDistance(gfst, &gdistance, rtype == REWEIGHT_TO_INITIAL, delta); + } else { + ArcMapFst> uwfst(ifst, + RmWeightMapper()); + ArcMapFst, ToGallicMapper> guwfst( + uwfst, ToGallicMapper()); + ShortestDistance(guwfst, &gdistance, rtype == REWEIGHT_TO_INITIAL, delta); + } + auto total_weight = GallicWeight::One(); + if (ptype & (kPushRemoveTotalWeight | kPushRemoveCommonAffix)) { + total_weight = + ComputeTotalWeight(gfst, gdistance, rtype == REWEIGHT_TO_INITIAL); + total_weight = GallicWeight( + ptype & kPushRemoveCommonAffix + ? total_weight.Value1() + : StringWeight::One(), + ptype & kPushRemoveTotalWeight ? total_weight.Value2() + : Weight::One()); + } + Reweight(&gfst, gdistance, rtype); + if (ptype & (kPushRemoveTotalWeight | kPushRemoveCommonAffix)) { + RemoveWeight(&gfst, total_weight, rtype == REWEIGHT_TO_FINAL); + } + FactorWeightFst, GallicFactor> + fwfst(gfst); + ArcMap(fwfst, ofst, FromGallicMapper()); + ofst->SetOutputSymbols(ifst.OutputSymbols()); + } else { + LOG(WARNING) << "Push: pushing type is set to 0, so not pushing"; + *ofst = ifst; + } +} + +} // namespace fst + +#endif // FST_PUSH_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/queue.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/queue.h new file mode 100644 index 0000000000..1dbdfdde43 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/queue.h @@ -0,0 +1,862 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Functions and classes for various FST state queues with a unified interface. + +#ifndef FST_QUEUE_H_ +#define FST_QUEUE_H_ + +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include + + +namespace fst { + +// The Queue interface is: +// +// template +// class Queue { +// public: +// using StateId = S; +// +// // Constructor: may need args (e.g., FST, comparator) for some queues. +// Queue(...) override; +// +// // Returns the head of the queue. +// StateId Head() const override; +// +// // Inserts a state. +// void Enqueue(StateId s) override; +// +// // Removes the head of the queue. +// void Dequeue() override; +// +// // Updates ordering of state s when weight changes, if necessary. +// void Update(StateId s) override; +// +// // Is the queue empty? +// bool Empty() const override; +// +// // Removes all states from the queue. +// void Clear() override; +// }; + +// State queue types. +enum QueueType { + TRIVIAL_QUEUE = 0, // Single state queue. + FIFO_QUEUE = 1, // First-in, first-out queue. + LIFO_QUEUE = 2, // Last-in, first-out queue. + SHORTEST_FIRST_QUEUE = 3, // Shortest-first queue. + TOP_ORDER_QUEUE = 4, // Topologically-ordered queue. + STATE_ORDER_QUEUE = 5, // State ID-ordered queue. + SCC_QUEUE = 6, // Component graph top-ordered meta-queue. + AUTO_QUEUE = 7, // Auto-selected queue. + OTHER_QUEUE = 8 +}; + +// QueueBase, templated on the StateId, is a virtual base class shared by all +// queues considered by AutoQueue. +template +class QueueBase { + public: + using StateId = S; + + virtual ~QueueBase() {} + + // Concrete implementation. + + explicit QueueBase(QueueType type) : queue_type_(type), error_(false) {} + + void SetError(bool error) { error_ = error; } + + bool Error() const { return error_; } + + QueueType Type() const { return queue_type_; } + + // Virtual interface. + + virtual StateId Head() const = 0; + virtual void Enqueue(StateId) = 0; + virtual void Dequeue() = 0; + virtual void Update(StateId) = 0; + virtual bool Empty() const = 0; + virtual void Clear() = 0; + + private: + QueueType queue_type_; + bool error_; +}; + +// Trivial queue discipline; one may enqueue at most one state at a time. It +// can be used for strongly connected components with only one state and no +// self-loops. +template +class TrivialQueue : public QueueBase { + public: + using StateId = S; + + TrivialQueue() : QueueBase(TRIVIAL_QUEUE), front_(kNoStateId) {} + + virtual ~TrivialQueue() = default; + + StateId Head() const final { return front_; } + + void Enqueue(StateId s) final { front_ = s; } + + void Dequeue() final { front_ = kNoStateId; } + + void Update(StateId) final {} + + bool Empty() const final { return front_ == kNoStateId; } + + void Clear() final { front_ = kNoStateId; } + + private: + StateId front_; +}; + +// First-in, first-out queue discipline. +// +// This is not a final class. +template +class FifoQueue : public QueueBase { + public: + using StateId = S; + + FifoQueue() : QueueBase(FIFO_QUEUE) {} + + virtual ~FifoQueue() = default; + + StateId Head() const override { return queue_.back(); } + + void Enqueue(StateId s) override { queue_.push_front(s); } + + void Dequeue() override { queue_.pop_back(); } + + void Update(StateId) override {} + + bool Empty() const override { return queue_.empty(); } + + void Clear() override { queue_.clear(); } + + private: + std::deque queue_; +}; + +// Last-in, first-out queue discipline. +template +class LifoQueue : public QueueBase { + public: + using StateId = S; + + LifoQueue() : QueueBase(LIFO_QUEUE) {} + + virtual ~LifoQueue() = default; + + StateId Head() const final { return queue_.front(); } + + void Enqueue(StateId s) final { queue_.push_front(s); } + + void Dequeue() final { queue_.pop_front(); } + + void Update(StateId) final {} + + bool Empty() const final { return queue_.empty(); } + + void Clear() final { queue_.clear(); } + + private: + std::deque queue_; +}; + +// Shortest-first queue discipline, templated on the StateId and as well as a +// comparison functor used to compare two StateIds. If a (single) state's order +// changes, it can be reordered in the queue with a call to Update(). If update +// is false, call to Update() does not reorder the queue. +// +// This is not a final class. +template +class ShortestFirstQueue : public QueueBase { + public: + using StateId = S; + + explicit ShortestFirstQueue(Compare comp) + : QueueBase(SHORTEST_FIRST_QUEUE), heap_(comp) {} + + virtual ~ShortestFirstQueue() = default; + + StateId Head() const override { return heap_.Top(); } + + void Enqueue(StateId s) override { + if (update) { + for (StateId i = key_.size(); i <= s; ++i) key_.push_back(kNoStateId); + key_[s] = heap_.Insert(s); + } else { + heap_.Insert(s); + } + } + + void Dequeue() override { + if (update) { + key_[heap_.Pop()] = kNoStateId; + } else { + heap_.Pop(); + } + } + + void Update(StateId s) override { + if (!update) return; + if (s >= key_.size() || key_[s] == kNoStateId) { + Enqueue(s); + } else { + heap_.Update(key_[s], s); + } + } + + bool Empty() const override { return heap_.Empty(); } + + void Clear() override { + heap_.Clear(); + if (update) key_.clear(); + } + + const Compare &GetCompare() const { return heap_.GetCompare(); } + + private: + Heap heap_; + std::vector key_; +}; + +namespace internal { + +// Given a vector that maps from states to weights, and a comparison functor +// for weights, this class defines a comparison function object between states. +template +class StateWeightCompare { + public: + using Weight = typename Less::Weight; + + StateWeightCompare(const std::vector &weights, const Less &less) + : weights_(weights), less_(less) {} + + bool operator()(const StateId s1, const StateId s2) const { + return less_(weights_[s1], weights_[s2]); + } + + private: + // Borrowed references. + const std::vector &weights_; + const Less &less_; +}; + +} // namespace internal + +// Shortest-first queue discipline, templated on the StateId and Weight, is +// specialized to use the weight's natural order for the comparison function. +template +class NaturalShortestFirstQueue final + : public ShortestFirstQueue< + S, internal::StateWeightCompare>> { + public: + using StateId = S; + using Compare = internal::StateWeightCompare>; + + explicit NaturalShortestFirstQueue(const std::vector &distance) + : ShortestFirstQueue(Compare(distance, less_)) {} + + virtual ~NaturalShortestFirstQueue() = default; + + private: + // This is non-static because the constructor for non-idempotent weights will + // result in a an error. + const NaturalLess less_{}; +}; + +// Topological-order queue discipline, templated on the StateId. States are +// ordered in the queue topologically. The FST must be acyclic. +template +class TopOrderQueue : public QueueBase { + public: + using StateId = S; + + // This constructor computes the topological order. It accepts an arc filter + // to limit the transitions considered in that computation (e.g., only the + // epsilon graph). + template + TopOrderQueue(const Fst &fst, ArcFilter filter) + : QueueBase(TOP_ORDER_QUEUE), + front_(0), + back_(kNoStateId), + order_(0), + state_(0) { + bool acyclic; + TopOrderVisitor top_order_visitor(&order_, &acyclic); + DfsVisit(fst, &top_order_visitor, filter); + if (!acyclic) { + FSTERROR() << "TopOrderQueue: FST is not acyclic"; + QueueBase::SetError(true); + } + state_.resize(order_.size(), kNoStateId); + } + + // This constructor is passed the pre-computed topological order. + explicit TopOrderQueue(const std::vector &order) + : QueueBase(TOP_ORDER_QUEUE), + front_(0), + back_(kNoStateId), + order_(order), + state_(order.size(), kNoStateId) {} + + virtual ~TopOrderQueue() = default; + + StateId Head() const final { return state_[front_]; } + + void Enqueue(StateId s) final { + if (front_ > back_) { + front_ = back_ = order_[s]; + } else if (order_[s] > back_) { + back_ = order_[s]; + } else if (order_[s] < front_) { + front_ = order_[s]; + } + state_[order_[s]] = s; + } + + void Dequeue() final { + state_[front_] = kNoStateId; + while ((front_ <= back_) && (state_[front_] == kNoStateId)) ++front_; + } + + void Update(StateId) final {} + + bool Empty() const final { return front_ > back_; } + + void Clear() final { + for (StateId s = front_; s <= back_; ++s) state_[s] = kNoStateId; + back_ = kNoStateId; + front_ = 0; + } + + private: + StateId front_; + StateId back_; + std::vector order_; + std::vector state_; +}; + +// State order queue discipline, templated on the StateId. States are ordered in +// the queue by state ID. +template +class StateOrderQueue : public QueueBase { + public: + using StateId = S; + + StateOrderQueue() + : QueueBase(STATE_ORDER_QUEUE), front_(0), back_(kNoStateId) {} + + virtual ~StateOrderQueue() = default; + + StateId Head() const final { return front_; } + + void Enqueue(StateId s) final { + if (front_ > back_) { + front_ = back_ = s; + } else if (s > back_) { + back_ = s; + } else if (s < front_) { + front_ = s; + } + while (enqueued_.size() <= s) enqueued_.push_back(false); + enqueued_[s] = true; + } + + void Dequeue() final { + enqueued_[front_] = false; + while ((front_ <= back_) && (enqueued_[front_] == false)) ++front_; + } + + void Update(StateId) final {} + + bool Empty() const final { return front_ > back_; } + + void Clear() final { + for (StateId i = front_; i <= back_; ++i) enqueued_[i] = false; + front_ = 0; + back_ = kNoStateId; + } + + private: + StateId front_; + StateId back_; + std::vector enqueued_; +}; + +// SCC topological-order meta-queue discipline, templated on the StateId and a +// queue used inside each SCC. It visits the SCCs of an FST in topological +// order. Its constructor is passed the queues to to use within an SCC. +template +class SccQueue : public QueueBase { + public: + using StateId = S; + + // Constructor takes a vector specifying the SCC number per state and a + // vector giving the queue to use per SCC number. + SccQueue(const std::vector &scc, + std::vector> *queue) + : QueueBase(SCC_QUEUE), + queue_(queue), + scc_(scc), + front_(0), + back_(kNoStateId) {} + + virtual ~SccQueue() = default; + + StateId Head() const final { + while ((front_ <= back_) && + (((*queue_)[front_] && (*queue_)[front_]->Empty()) || + (((*queue_)[front_] == nullptr) && + ((front_ >= trivial_queue_.size()) || + (trivial_queue_[front_] == kNoStateId))))) { + ++front_; + } + if ((*queue_)[front_]) { + return (*queue_)[front_]->Head(); + } else { + return trivial_queue_[front_]; + } + } + + void Enqueue(StateId s) final { + if (front_ > back_) { + front_ = back_ = scc_[s]; + } else if (scc_[s] > back_) { + back_ = scc_[s]; + } else if (scc_[s] < front_) { + front_ = scc_[s]; + } + if ((*queue_)[scc_[s]]) { + (*queue_)[scc_[s]]->Enqueue(s); + } else { + while (trivial_queue_.size() <= scc_[s]) { + trivial_queue_.push_back(kNoStateId); + } + trivial_queue_[scc_[s]] = s; + } + } + + void Dequeue() final { + if ((*queue_)[front_]) { + (*queue_)[front_]->Dequeue(); + } else if (front_ < trivial_queue_.size()) { + trivial_queue_[front_] = kNoStateId; + } + } + + void Update(StateId s) final { + if ((*queue_)[scc_[s]]) (*queue_)[scc_[s]]->Update(s); + } + + bool Empty() const final { + // Queues SCC number back_ is not empty unless back_ == front_. + if (front_ < back_) { + return false; + } else if (front_ > back_) { + return true; + } else if ((*queue_)[front_]) { + return (*queue_)[front_]->Empty(); + } else { + return (front_ >= trivial_queue_.size()) || + (trivial_queue_[front_] == kNoStateId); + } + } + + void Clear() final { + for (StateId i = front_; i <= back_; ++i) { + if ((*queue_)[i]) { + (*queue_)[i]->Clear(); + } else if (i < trivial_queue_.size()) { + trivial_queue_[i] = kNoStateId; + } + } + front_ = 0; + back_ = kNoStateId; + } + + private: + std::vector> *queue_; + const std::vector &scc_; + mutable StateId front_; + StateId back_; + std::vector trivial_queue_; +}; + +// Automatic queue discipline. It selects a queue discipline for a given FST +// based on its properties. +template +class AutoQueue : public QueueBase { + public: + using StateId = S; + + // This constructor takes a state distance vector that, if non-null and if + // the Weight type has the path property, will entertain the shortest-first + // queue using the natural order w.r.t to the distance. + template + AutoQueue(const Fst &fst, + const std::vector *distance, ArcFilter filter) + : QueueBase(AUTO_QUEUE) { + using Weight = typename Arc::Weight; + using Less = NaturalLess; + using Compare = internal::StateWeightCompare; + // First checks if the FST is known to have these properties. + const auto props = + fst.Properties(kAcyclic | kCyclic | kTopSorted | kUnweighted, false); + if ((props & kTopSorted) || fst.Start() == kNoStateId) { + queue_.reset(new StateOrderQueue()); + VLOG(2) << "AutoQueue: using state-order discipline"; + } else if (props & kAcyclic) { + queue_.reset(new TopOrderQueue(fst, filter)); + VLOG(2) << "AutoQueue: using top-order discipline"; + } else if ((props & kUnweighted) && (Weight::Properties() & kIdempotent)) { + queue_.reset(new LifoQueue()); + VLOG(2) << "AutoQueue: using LIFO discipline"; + } else { + uint64 properties; + // Decomposes into strongly-connected components. + SccVisitor scc_visitor(&scc_, nullptr, nullptr, &properties); + DfsVisit(fst, &scc_visitor, filter); + auto nscc = *std::max_element(scc_.begin(), scc_.end()) + 1; + std::vector queue_types(nscc); + std::unique_ptr less; + std::unique_ptr comp; + if (distance && (Weight::Properties() & kPath) == kPath) { + less.reset(new Less); + comp.reset(new Compare(*distance, *less)); + } + // Finds the queue type to use per SCC. + bool unweighted; + bool all_trivial; + SccQueueType(fst, scc_, &queue_types, filter, less.get(), &all_trivial, + &unweighted); + // If unweighted and semiring is idempotent, uses LIFO queue. + if (unweighted) { + queue_.reset(new LifoQueue()); + VLOG(2) << "AutoQueue: using LIFO discipline"; + return; + } + // If all the SCC are trivial, the FST is acyclic and the scc number gives + // the topological order. + if (all_trivial) { + queue_.reset(new TopOrderQueue(scc_)); + VLOG(2) << "AutoQueue: using top-order discipline"; + return; + } + VLOG(2) << "AutoQueue: using SCC meta-discipline"; + queues_.resize(nscc); + for (StateId i = 0; i < nscc; ++i) { + switch (queue_types[i]) { + case TRIVIAL_QUEUE: + queues_[i].reset(); + VLOG(3) << "AutoQueue: SCC #" << i << ": using trivial discipline"; + break; + case SHORTEST_FIRST_QUEUE: + queues_[i].reset( + new ShortestFirstQueue(*comp)); + VLOG(3) << "AutoQueue: SCC #" << i + << ": using shortest-first discipline"; + break; + case LIFO_QUEUE: + queues_[i].reset(new LifoQueue()); + VLOG(3) << "AutoQueue: SCC #" << i << ": using LIFO discipline"; + break; + case FIFO_QUEUE: + default: + queues_[i].reset(new FifoQueue()); + VLOG(3) << "AutoQueue: SCC #" << i << ": using FIFO discipine"; + break; + } + } + queue_.reset(new SccQueue>(scc_, &queues_)); + } + } + + virtual ~AutoQueue() = default; + + StateId Head() const final { return queue_->Head(); } + + void Enqueue(StateId s) final { queue_->Enqueue(s); } + + void Dequeue() final { queue_->Dequeue(); } + + void Update(StateId s) final { queue_->Update(s); } + + bool Empty() const final { return queue_->Empty(); } + + void Clear() final { queue_->Clear(); } + + private: + template + static void SccQueueType(const Fst &fst, const std::vector &scc, + std::vector *queue_types, + ArcFilter filter, Less *less, bool *all_trivial, + bool *unweighted); + + std::unique_ptr> queue_; + std::vector>> queues_; + std::vector scc_; +}; + +// Examines the states in an FST's strongly connected components and determines +// which type of queue to use per SCC. Stores result as a vector of QueueTypes +// which is assumed to have length equal to the number of SCCs. An arc filter +// is used to limit the transitions considered (e.g., only the epsilon graph). +// The argument all_trivial is set to true if every queue is the trivial queue. +// The argument unweighted is set to true if the semiring is idempotent and all +// the arc weights are equal to Zero() or One(). +template +template +void AutoQueue::SccQueueType(const Fst &fst, + const std::vector &scc, + std::vector *queue_type, + ArcFilter filter, Less *less, + bool *all_trivial, bool *unweighted) { + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + *all_trivial = true; + *unweighted = true; + for (StateId i = 0; i < queue_type->size(); ++i) { + (*queue_type)[i] = TRIVIAL_QUEUE; + } + for (StateIterator> sit(fst); !sit.Done(); sit.Next()) { + const auto state = sit.Value(); + for (ArcIterator> ait(fst, state); !ait.Done(); ait.Next()) { + const auto &arc = ait.Value(); + if (!filter(arc)) continue; + if (scc[state] == scc[arc.nextstate]) { + auto &type = (*queue_type)[scc[state]]; + if (!less || ((*less)(arc.weight, Weight::One()))) { + type = FIFO_QUEUE; + } else if ((type == TRIVIAL_QUEUE) || (type == LIFO_QUEUE)) { + if (!(Weight::Properties() & kIdempotent) || + (arc.weight != Weight::Zero() && arc.weight != Weight::One())) { + type = SHORTEST_FIRST_QUEUE; + } else { + type = LIFO_QUEUE; + } + } + if (type != TRIVIAL_QUEUE) *all_trivial = false; + } + if (!(Weight::Properties() & kIdempotent) || + (arc.weight != Weight::Zero() && arc.weight != Weight::One())) { + *unweighted = false; + } + } + } +} + +// An A* estimate is a function object that maps from a state ID to a an +// estimate of the shortest distance to the final states. + +// A trivial A* estimate, yielding a queue which behaves the same in Dijkstra's +// algorithm. +template +struct TrivialAStarEstimate { + const Weight &operator()(StateId) const { return Weight::One(); } +}; + +// A non-trivial A* estimate using a vector of the estimated future costs. +template +class NaturalAStarEstimate { + public: + NaturalAStarEstimate(const std::vector &beta) : + beta_(beta) {} + + const Weight &operator()(StateId s) const { return beta_[s]; } + + private: + const std::vector &beta_; +}; + +// Given a vector that maps from states to weights representing the shortest +// distance from the initial state, a comparison function object between +// weights, and an estimate of the shortest distance to the final states, this +// class defines a comparison function object between states. +template +class AStarWeightCompare { + public: + using StateId = S; + using Weight = typename Less::Weight; + + AStarWeightCompare(const std::vector &weights, const Less &less, + const Estimate &estimate) + : weights_(weights), less_(less), estimate_(estimate) {} + + bool operator()(StateId s1, StateId s2) const { + const auto w1 = Times(weights_[s1], estimate_(s1)); + const auto w2 = Times(weights_[s2], estimate_(s2)); + return less_(w1, w2); + } + + const Estimate &GetEstimate() const { return estimate_; } + + private: + const std::vector &weights_; + const Less &less_; + const Estimate &estimate_; +}; + +// A* queue discipline templated on StateId, Weight, and Estimate. +template +class NaturalAStarQueue : public ShortestFirstQueue< + S, AStarWeightCompare, Estimate>> { + public: + using StateId = S; + using Compare = AStarWeightCompare, Estimate>; + + NaturalAStarQueue(const std::vector &distance, + const Estimate &estimate) + : ShortestFirstQueue( + Compare(distance, less_, estimate)) {} + + ~NaturalAStarQueue() = default; + + private: + // This is non-static because the constructor for non-idempotent weights will + // result in a an error. + const NaturalLess less_{}; +}; + +// A state equivalence class is a function object that maps from a state ID to +// an equivalence class (state) ID. The trivial equivalence class maps a state +// ID to itself. +template +struct TrivialStateEquivClass { + StateId operator()(StateId s) const { return s; } +}; + +// Distance-based pruning queue discipline: Enqueues a state only when its +// shortest distance (so far), as specified by distance, is less than (as +// specified by comp) the shortest distance Times() the threshold to any state +// in the same equivalence class, as specified by the functor class_func. The +// underlying queue discipline is specified by queue. The ownership of queue is +// given to this class. +// +// This is not a final class. +template +class PruneQueue : public QueueBase { + public: + using StateId = typename Queue::StateId; + using Weight = typename Less::Weight; + + PruneQueue(const std::vector &distance, Queue *queue, + const Less &less, const ClassFnc &class_fnc, Weight threshold) + : QueueBase(OTHER_QUEUE), + distance_(distance), + queue_(queue), + less_(less), + class_fnc_(class_fnc), + threshold_(std::move(threshold)) {} + + virtual ~PruneQueue() = default; + + StateId Head() const override { return queue_->Head(); } + + void Enqueue(StateId s) override { + const auto c = class_fnc_(s); + if (c >= class_distance_.size()) { + class_distance_.resize(c + 1, Weight::Zero()); + } + if (less_(distance_[s], class_distance_[c])) { + class_distance_[c] = distance_[s]; + } + // Enqueues only if below threshold limit. + const auto limit = Times(class_distance_[c], threshold_); + if (less_(distance_[s], limit)) queue_->Enqueue(s); + } + + void Dequeue() override { queue_->Dequeue(); } + + void Update(StateId s) override { + const auto c = class_fnc_(s); + if (less_(distance_[s], class_distance_[c])) { + class_distance_[c] = distance_[s]; + } + queue_->Update(s); + } + + bool Empty() const override { return queue_->Empty(); } + + void Clear() override { queue_->Clear(); } + + private: + const std::vector &distance_; // Shortest distance to state. + std::unique_ptr queue_; + const Less &less_; // Borrowed reference. + const ClassFnc &class_fnc_; // Equivalence class functor. + Weight threshold_; // Pruning weight threshold. + std::vector class_distance_; // Shortest distance to class. +}; + +// Pruning queue discipline (see above) using the weight's natural order for the +// comparison function. The ownership of the queue argument is given to this +// class. +template +class NaturalPruneQueue final + : public PruneQueue, ClassFnc> { + public: + using StateId = typename Queue::StateId; + + NaturalPruneQueue(const std::vector &distance, Queue *queue, + const ClassFnc &class_fnc, Weight threshold) + : PruneQueue, ClassFnc>( + distance, queue, NaturalLess(), class_fnc, threshold) {} + + virtual ~NaturalPruneQueue() = default; +}; + +// Filter-based pruning queue discipline: enqueues a state only if allowed by +// the filter, specified by the state filter functor argument. The underlying +// queue discipline is specified by the queue argument. The ownership of the +// queue is given to this class. +template +class FilterQueue : public QueueBase { + public: + using StateId = typename Queue::StateId; + + FilterQueue(Queue *queue, const Filter &filter) + : QueueBase(OTHER_QUEUE), queue_(queue), filter_(filter) {} + + virtual ~FilterQueue() = default; + + StateId Head() const final { return queue_->Head(); } + + // Enqueues only if allowed by state filter. + void Enqueue(StateId s) final { + if (filter_(s)) queue_->Enqueue(s); + } + + void Dequeue() final { queue_->Dequeue(); } + + void Update(StateId s) final {} + + bool Empty() const final { return queue_->Empty(); } + + void Clear() final { queue_->Clear(); } + + private: + std::unique_ptr queue_; + const Filter &filter_; +}; + +} // namespace fst + +#endif // FST_QUEUE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/randequivalent.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/randequivalent.h new file mode 100644 index 0000000000..73108b46d5 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/randequivalent.h @@ -0,0 +1,114 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Tests if two FSTS are equivalent by checking if random strings from one FST +// are transduced the same by both FSTs. + +#ifndef FST_RANDEQUIVALENT_H_ +#define FST_RANDEQUIVALENT_H_ + +#include + +#include +#include +#include +#include +#include +#include + + +namespace fst { + +// Test if two FSTs are stochastically equivalent by randomly generating +// random paths through the FSTs. +// +// For each randomly generated path, the algorithm computes for each +// of the two FSTs the sum of the weights of all the successful paths +// sharing the same input and output labels as the considered randomly +// generated path and checks that these two values are within a user-specified +// delta. Returns optional error value (when FLAGS_error_fatal = false). +template +bool RandEquivalent(const Fst &fst1, const Fst &fst2, + int32 num_paths, float delta, + const RandGenOptions &opts, + bool *error = nullptr) { + using Weight = typename Arc::Weight; + if (error) *error = false; + // Checks that the symbol table are compatible. + if (!CompatSymbols(fst1.InputSymbols(), fst2.InputSymbols()) || + !CompatSymbols(fst1.OutputSymbols(), fst2.OutputSymbols())) { + FSTERROR() << "RandEquivalent: Input/output symbol tables of 1st " + << "argument do not match input/output symbol tables of 2nd " + << "argument"; + if (error) *error = true; + return false; + } + static const ILabelCompare icomp; + static const OLabelCompare ocomp; + VectorFst sfst1(fst1); + VectorFst sfst2(fst2); + Connect(&sfst1); + Connect(&sfst2); + ArcSort(&sfst1, icomp); + ArcSort(&sfst2, icomp); + bool result = true; + for (int32 n = 0; n < num_paths; ++n) { + VectorFst path; + const auto &fst = rand() % 2 ? sfst1 : sfst2; // NOLINT + RandGen(fst, &path, opts); + VectorFst ipath(path); + VectorFst opath(path); + Project(&ipath, PROJECT_INPUT); + Project(&opath, PROJECT_OUTPUT); + VectorFst cfst1, pfst1; + Compose(ipath, sfst1, &cfst1); + ArcSort(&cfst1, ocomp); + Compose(cfst1, opath, &pfst1); + // Gives up if there are epsilon cycles in a non-idempotent semiring. + if (!(Weight::Properties() & kIdempotent) && + pfst1.Properties(kCyclic, true)) { + continue; + } + const auto sum1 = ShortestDistance(pfst1); + VectorFst cfst2; + Compose(ipath, sfst2, &cfst2); + ArcSort(&cfst2, ocomp); + VectorFst pfst2; + Compose(cfst2, opath, &pfst2); + // Gives up if there are epsilon cycles in a non-idempotent semiring. + if (!(Weight::Properties() & kIdempotent) && + pfst2.Properties(kCyclic, true)) { + continue; + } + const auto sum2 = ShortestDistance(pfst2); + if (!ApproxEqual(sum1, sum2, delta)) { + VLOG(1) << "Sum1 = " << sum1; + VLOG(1) << "Sum2 = " << sum2; + result = false; + break; + } + } + if (fst1.Properties(kError, false) || fst2.Properties(kError, false)) { + if (error) *error = true; + return false; + } + return result; +} + +// Tests if two FSTs are equivalent by randomly generating a nnum_paths paths +// (no longer than the path_length) using a user-specified seed, optionally +// indicating an error setting an optional error argument to true. +template +bool RandEquivalent(const Fst &fst1, const Fst &fst2, int32 num_paths, + float delta = kDelta, time_t seed = time(nullptr), + int32 max_length = std::numeric_limits::max(), + bool *error = nullptr) { + const UniformArcSelector uniform_selector(seed); + const RandGenOptions> opts(uniform_selector, + max_length); + return RandEquivalent(fst1, fst2, num_paths, delta, opts, error); +} + +} // namespace fst + +#endif // FST_RANDEQUIVALENT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/randgen.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/randgen.h new file mode 100644 index 0000000000..d312ef1757 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/randgen.h @@ -0,0 +1,750 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Classes and functions to generate random paths through an FST. + +#ifndef FST_RANDGEN_H_ +#define FST_RANDGEN_H_ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace fst { + +// The RandGenFst class is roughly similar to ArcMapFst in that it takes two +// template parameters denoting the input and output arc types. However, it also +// takes an additional template parameter which specifies a sampler object which +// samples (with replacement) arcs from an FST state. The sampler in turn takes +// a template parameter for a selector object which actually chooses the arc. +// +// Arc selector functors are used to select a random transition given an FST +// state s, returning a number N such that 0 <= N <= NumArcs(s). If N is +// NumArcs(s), then the final weight is selected; otherwise the N-th arc is +// selected. It is assumed these are not applied to any state which is neither +// final nor has any arcs leaving it. + +// Randomly selects a transition using the uniform distribution. This class is +// not thread-safe. +template +class UniformArcSelector { + public: + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + // Constructs a selector with a non-deterministic seed. + UniformArcSelector() : rand_(std::random_device()()) {} + // Constructs a selector with a given seed. + explicit UniformArcSelector(uint64 seed) : rand_(seed) {} + + size_t operator()(const Fst &fst, StateId s) const { + const auto n = fst.NumArcs(s) + (fst.Final(s) != Weight::Zero()); + return static_cast( + std::uniform_int_distribution<>(0, n - 1)(rand_)); + } + + private: + mutable std::mt19937_64 rand_; +}; + +// Randomly selects a transition w.r.t. the weights treated as negative log +// probabilities after normalizing for the total weight leaving the state. Zero +// transitions are disregarded. It assumed that Arc::Weight::Value() accesses +// the floating point representation of the weight. This class is not +// thread-safe. +template +class LogProbArcSelector { + public: + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + // Constructs a selector with a non-deterministic seed. + LogProbArcSelector() : rand_(std::random_device()()) {} + // Constructs a selector with a given seed. + explicit LogProbArcSelector(uint64 seed) : rand_(seed) {} + + size_t operator()(const Fst &fst, StateId s) const { + // Finds total weight leaving state. + auto sum = Log64Weight::Zero(); + ArcIterator> aiter(fst, s); + for (; !aiter.Done(); aiter.Next()) { + const auto &arc = aiter.Value(); + sum = Plus(sum, to_log_weight_(arc.weight)); + } + sum = Plus(sum, to_log_weight_(fst.Final(s))); + const double threshold = + std::uniform_real_distribution<>(0, exp(-sum.Value()))(rand_); + auto p = Log64Weight::Zero(); + size_t n = 0; + for (aiter.Reset(); !aiter.Done(); aiter.Next(), ++n) { + p = Plus(p, to_log_weight_(aiter.Value().weight)); + if (exp(-p.Value()) > threshold) return n; + } + return n; + } + + private: + mutable std::mt19937_64 rand_; + WeightConvert to_log_weight_; +}; + +// Useful alias when using StdArc. +using StdArcSelector = LogProbArcSelector; + +// Same as LogProbArcSelector but use CacheLogAccumulator to cache the weight +// accumulation computations. This class is not thread-safe. +template +class FastLogProbArcSelector : public LogProbArcSelector { + public: + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using LogProbArcSelector::operator(); + + // Constructs a selector with a non-deterministic seed. + FastLogProbArcSelector() : seed_(std::random_device()()), rand_(seed_) {} + // Constructs a selector with a given seed. + explicit FastLogProbArcSelector(uint64 seed) : seed_(seed), rand_(seed_) {} + + size_t operator()(const Fst &fst, StateId s, + CacheLogAccumulator *accumulator) const { + accumulator->SetState(s); + ArcIterator> aiter(fst, s); + // Finds total weight leaving state. + const double sum = to_log_weight_(accumulator->Sum(fst.Final(s), &aiter, 0, + fst.NumArcs(s))) + .Value(); + const double r = -log(std::uniform_real_distribution<>(0, 1)(rand_)); + Weight w = from_log_weight_(r + sum); + aiter.Reset(); + return accumulator->LowerBound(w, &aiter); + } + + uint64 Seed() const { return seed_; } + + private: + const uint64 seed_; + mutable std::mt19937_64 rand_; + WeightConvert to_log_weight_; + WeightConvert from_log_weight_; +}; + +// Random path state info maintained by RandGenFst and passed to samplers. +template +struct RandState { + using StateId = typename Arc::StateId; + + StateId state_id; // Current input FST state. + size_t nsamples; // Number of samples to be sampled at this state. + size_t length; // Length of path to this random state. + size_t select; // Previous sample arc selection. + const RandState *parent; // Previous random state on this path. + + explicit RandState(StateId state_id, size_t nsamples = 0, size_t length = 0, + size_t select = 0, const RandState *parent = nullptr) + : state_id(state_id), + nsamples(nsamples), + length(length), + select(select), + parent(parent) {} + + RandState() : RandState(kNoStateId) {} +}; + +// This class, given an arc selector, samples, with replacement, multiple random +// transitions from an FST's state. This is a generic version with a +// straightforward use of the arc selector. Specializations may be defined for +// arc selectors for greater efficiency or special behavior. +template +class ArcSampler { + public: + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + // The max_length argument may be interpreted (or ignored) by a selector as + // it chooses. This generic version interprets this literally. + ArcSampler(const Fst &fst, const Selector &selector, + int32 max_length = std::numeric_limits::max()) + : fst_(fst), selector_(selector), max_length_(max_length) {} + + // Allow updating FST argument; pass only if changed. + ArcSampler(const ArcSampler &sampler, + const Fst *fst = nullptr) + : fst_(fst ? *fst : sampler.fst_), + selector_(sampler.selector_), + max_length_(sampler.max_length_) { + Reset(); + } + + // Samples a fixed number of samples from the given state. The length argument + // specifies the length of the path to the state. Returns true if the samples + // were collected. No samples may be collected if either there are no + // transitions leaving the state and the state is non-final, or if the path + // length has been exceeded. Iterator members are provided to read the samples + // in the order in which they were collected. + bool Sample(const RandState &rstate) { + sample_map_.clear(); + if ((fst_.NumArcs(rstate.state_id) == 0 && + fst_.Final(rstate.state_id) == Weight::Zero()) || + rstate.length == max_length_) { + Reset(); + return false; + } + for (size_t i = 0; i < rstate.nsamples; ++i) { + ++sample_map_[selector_(fst_, rstate.state_id)]; + } + Reset(); + return true; + } + + // More samples? + bool Done() const { return sample_iter_ == sample_map_.end(); } + + // Gets the next sample. + void Next() { ++sample_iter_; } + + std::pair Value() const { return *sample_iter_; } + + void Reset() { sample_iter_ = sample_map_.begin(); } + + bool Error() const { return false; } + + private: + const Fst &fst_; + const Selector &selector_; + const int32 max_length_; + + // Stores (N, K) as described for Value(). + std::map sample_map_; + std::map::const_iterator sample_iter_; + + ArcSampler &operator=(const ArcSampler &) = delete; +}; + +// Samples one sample of num_to_sample dimensions from a multinomial +// distribution parameterized by a vector of probabilities. The result +// container should be pre-initialized (e.g., an empty map or a zeroed vector +// sized the same as the vector of probabilities. +// probs.size()). +template +void OneMultinomialSample(const std::vector &probs, + size_t num_to_sample, Result *result, RNG *rng) { + // Left-over probability mass. + double norm = 0; + for (double p : probs) norm += p; + // Left-over number of samples needed. + for (size_t i = 0; i < probs.size(); ++i) { + size_t num_sampled = 0; + if (probs[i] > 0) { + std::binomial_distribution<> d(num_to_sample, probs[i] / norm); + num_sampled = d(*rng); + } + if (num_sampled != 0) (*result)[i] = num_sampled; + norm -= probs[i]; + num_to_sample -= num_sampled; + } +} + +// Specialization for FastLogProbArcSelector. +template +class ArcSampler> { + public: + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using Accumulator = CacheLogAccumulator; + using Selector = FastLogProbArcSelector; + + ArcSampler(const Fst &fst, const Selector &selector, + int32 max_length = std::numeric_limits::max()) + : fst_(fst), + selector_(selector), + max_length_(max_length), + accumulator_(new Accumulator()) { + accumulator_->Init(fst); + rng_.seed(selector_.Seed()); + } + + ArcSampler(const ArcSampler &sampler, + const Fst *fst = nullptr) + : fst_(fst ? *fst : sampler.fst_), + selector_(sampler.selector_), + max_length_(sampler.max_length_) { + if (fst) { + accumulator_.reset(new Accumulator()); + accumulator_->Init(*fst); + } else { // Shallow copy. + accumulator_.reset(new Accumulator(*sampler.accumulator_)); + } + } + + bool Sample(const RandState &rstate) { + sample_map_.clear(); + if ((fst_.NumArcs(rstate.state_id) == 0 && + fst_.Final(rstate.state_id) == Weight::Zero()) || + rstate.length == max_length_) { + Reset(); + return false; + } + if (fst_.NumArcs(rstate.state_id) + 1 < rstate.nsamples) { + MultinomialSample(rstate); + Reset(); + return true; + } + for (size_t i = 0; i < rstate.nsamples; ++i) { + ++sample_map_[selector_(fst_, rstate.state_id, accumulator_.get())]; + } + Reset(); + return true; + } + + bool Done() const { return sample_iter_ == sample_map_.end(); } + + void Next() { ++sample_iter_; } + + std::pair Value() const { return *sample_iter_; } + + void Reset() { sample_iter_ = sample_map_.begin(); } + + bool Error() const { return accumulator_->Error(); } + + private: + using RNG = std::mt19937; + + // Sample according to the multinomial distribution of rstate.nsamples draws + // from p_. + void MultinomialSample(const RandState &rstate) { + p_.clear(); + for (ArcIterator> aiter(fst_, rstate.state_id); !aiter.Done(); + aiter.Next()) { + p_.push_back(exp(-to_log_weight_(aiter.Value().weight).Value())); + } + if (fst_.Final(rstate.state_id) != Weight::Zero()) { + p_.push_back(exp(-to_log_weight_(fst_.Final(rstate.state_id)).Value())); + } + if (rstate.nsamples < std::numeric_limits::max()) { + OneMultinomialSample(p_, rstate.nsamples, &sample_map_, &rng_); + } else { + for (size_t i = 0; i < p_.size(); ++i) { + sample_map_[i] = ceil(p_[i] * rstate.nsamples); + } + } + } + + const Fst &fst_; + const Selector &selector_; + const int32 max_length_; + + // Stores (N, K) for Value(). + std::map sample_map_; + std::map::const_iterator sample_iter_; + + std::unique_ptr accumulator_; + RNG rng_; // Random number generator. + std::vector p_; // Multinomial parameters. + WeightConvert to_log_weight_; +}; + +// Options for random path generation with RandGenFst. The template argument is +// a sampler, typically the class ArcSampler. Ownership of the sampler is taken +// by RandGenFst. +template +struct RandGenFstOptions : public CacheOptions { + Sampler *sampler; // How to sample transitions at a state. + int32 npath; // Number of paths to generate. + bool weighted; // Is the output tree weighted by path count, or + // is it just an unweighted DAG? + bool remove_total_weight; // Remove total weight when output is weighted. + + RandGenFstOptions(const CacheOptions &opts, Sampler *sampler, int32 npath = 1, + bool weighted = true, bool remove_total_weight = false) + : CacheOptions(opts), + sampler(sampler), + npath(npath), + weighted(weighted), + remove_total_weight(remove_total_weight) {} +}; + +namespace internal { + +// Implementation of RandGenFst. +template +class RandGenFstImpl : public CacheImpl { + public: + using FstImpl::SetType; + using FstImpl::SetProperties; + using FstImpl::SetInputSymbols; + using FstImpl::SetOutputSymbols; + + using CacheBaseImpl>::PushArc; + using CacheBaseImpl>::HasArcs; + using CacheBaseImpl>::HasFinal; + using CacheBaseImpl>::HasStart; + using CacheBaseImpl>::SetArcs; + using CacheBaseImpl>::SetFinal; + using CacheBaseImpl>::SetStart; + + using Label = typename FromArc::Label; + using StateId = typename FromArc::StateId; + using FromWeight = typename FromArc::Weight; + + using ToWeight = typename ToArc::Weight; + + RandGenFstImpl(const Fst &fst, + const RandGenFstOptions &opts) + : CacheImpl(opts), + fst_(fst.Copy()), + sampler_(opts.sampler), + npath_(opts.npath), + weighted_(opts.weighted), + remove_total_weight_(opts.remove_total_weight), + superfinal_(kNoLabel) { + SetType("randgen"); + SetProperties( + RandGenProperties(fst.Properties(kFstProperties, false), weighted_), + kCopyProperties); + SetInputSymbols(fst.InputSymbols()); + SetOutputSymbols(fst.OutputSymbols()); + } + + RandGenFstImpl(const RandGenFstImpl &impl) + : CacheImpl(impl), + fst_(impl.fst_->Copy(true)), + sampler_(new Sampler(*impl.sampler_, fst_.get())), + npath_(impl.npath_), + weighted_(impl.weighted_), + superfinal_(kNoLabel) { + SetType("randgen"); + SetProperties(impl.Properties(), kCopyProperties); + SetInputSymbols(impl.InputSymbols()); + SetOutputSymbols(impl.OutputSymbols()); + } + + StateId Start() { + if (!HasStart()) { + const auto s = fst_->Start(); + if (s == kNoStateId) return kNoStateId; + SetStart(state_table_.size()); + state_table_.emplace_back( + new RandState(s, npath_, 0, 0, nullptr)); + } + return CacheImpl::Start(); + } + + ToWeight Final(StateId s) { + if (!HasFinal(s)) Expand(s); + return CacheImpl::Final(s); + } + + size_t NumArcs(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumArcs(s); + } + + size_t NumInputEpsilons(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumInputEpsilons(s); + } + + size_t NumOutputEpsilons(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumOutputEpsilons(s); + } + + uint64 Properties() const override { return Properties(kFstProperties); } + + // Sets error if found, and returns other FST impl properties. + uint64 Properties(uint64 mask) const override { + if ((mask & kError) && + (fst_->Properties(kError, false) || sampler_->Error())) { + SetProperties(kError, kError); + } + return FstImpl::Properties(mask); + } + + void InitArcIterator(StateId s, ArcIteratorData *data) { + if (!HasArcs(s)) Expand(s); + CacheImpl::InitArcIterator(s, data); + } + + // Computes the outgoing transitions from a state, creating new destination + // states as needed. + void Expand(StateId s) { + if (s == superfinal_) { + SetFinal(s, ToWeight::One()); + SetArcs(s); + return; + } + SetFinal(s, ToWeight::Zero()); + const auto &rstate = *state_table_[s]; + sampler_->Sample(rstate); + ArcIterator> aiter(*fst_, rstate.state_id); + const auto narcs = fst_->NumArcs(rstate.state_id); + for (; !sampler_->Done(); sampler_->Next()) { + const auto &sample_pair = sampler_->Value(); + const auto pos = sample_pair.first; + const auto count = sample_pair.second; + double prob = static_cast(count) / rstate.nsamples; + if (pos < narcs) { // Regular transition. + aiter.Seek(sample_pair.first); + const auto &aarc = aiter.Value(); + const auto weight = + weighted_ ? to_weight_(Log64Weight(-log(prob))) : ToWeight::One(); + const ToArc barc(aarc.ilabel, aarc.olabel, weight, state_table_.size()); + PushArc(s, barc); + auto *nrstate = new RandState(aarc.nextstate, count, + rstate.length + 1, pos, &rstate); + state_table_.emplace_back(nrstate); + } else { // Super-final transition. + if (weighted_) { + const auto weight = + remove_total_weight_ + ? to_weight_(Log64Weight(-log(prob))) + : to_weight_(Log64Weight(-log(prob * npath_))); + SetFinal(s, weight); + } else { + if (superfinal_ == kNoLabel) { + superfinal_ = state_table_.size(); + state_table_.emplace_back( + new RandState(kNoStateId, 0, 0, 0, nullptr)); + } + for (size_t n = 0; n < count; ++n) { + const ToArc barc(0, 0, ToWeight::One(), superfinal_); + PushArc(s, barc); + } + } + } + } + SetArcs(s); + } + + private: + const std::unique_ptr> fst_; + std::unique_ptr sampler_; + const int32 npath_; + std::vector>> state_table_; + const bool weighted_; + bool remove_total_weight_; + StateId superfinal_; + WeightConvert to_weight_; +}; + +} // namespace internal + +// FST class to randomly generate paths through an FST, with details controlled +// by RandGenOptionsFst. Output format is a tree weighted by the path count. +template +class RandGenFst + : public ImplToFst> { + public: + using Label = typename FromArc::Label; + using StateId = typename FromArc::StateId; + using Weight = typename FromArc::Weight; + + using Store = DefaultCacheStore; + using State = typename Store::State; + + using Impl = internal::RandGenFstImpl; + + friend class ArcIterator>; + friend class StateIterator>; + + RandGenFst(const Fst &fst, const RandGenFstOptions &opts) + : ImplToFst(std::make_shared(fst, opts)) {} + + // See Fst<>::Copy() for doc. + RandGenFst(const RandGenFst &fst, bool safe = false) + : ImplToFst(fst, safe) {} + + // Get a copy of this RandGenFst. See Fst<>::Copy() for further doc. + RandGenFst *Copy(bool safe = false) const override { + return new RandGenFst(*this, safe); + } + + inline void InitStateIterator(StateIteratorData *data) const override; + + void InitArcIterator(StateId s, ArcIteratorData *data) const override { + GetMutableImpl()->InitArcIterator(s, data); + } + + private: + using ImplToFst::GetImpl; + using ImplToFst::GetMutableImpl; + + RandGenFst &operator=(const RandGenFst &) = delete; +}; + +// Specialization for RandGenFst. +template +class StateIterator> + : public CacheStateIterator> { + public: + explicit StateIterator(const RandGenFst &fst) + : CacheStateIterator>( + fst, fst.GetMutableImpl()) {} +}; + +// Specialization for RandGenFst. +template +class ArcIterator> + : public CacheArcIterator> { + public: + using StateId = typename FromArc::StateId; + + ArcIterator(const RandGenFst &fst, StateId s) + : CacheArcIterator>( + fst.GetMutableImpl(), s) { + if (!fst.GetImpl()->HasArcs(s)) fst.GetMutableImpl()->Expand(s); + } +}; + +template +inline void RandGenFst::InitStateIterator( + StateIteratorData *data) const { + data->base = new StateIterator>(*this); +} + +// Options for random path generation. +template +struct RandGenOptions { + const Selector &selector; // How an arc is selected at a state. + int32 max_length; // Maximum path length. + int32 npath; // Number of paths to generate. + bool weighted; // Is the output tree weighted by path count, or + // is it just an unweighted DAG? + bool remove_total_weight; // Remove total weight when output is weighted? + + explicit RandGenOptions(const Selector &selector, + int32 max_length = std::numeric_limits::max(), + int32 npath = 1, bool weighted = false, + bool remove_total_weight = false) + : selector(selector), + max_length(max_length), + npath(npath), + weighted(weighted), + remove_total_weight(remove_total_weight) {} +}; + +namespace internal { + +template +class RandGenVisitor { + public: + using StateId = typename FromArc::StateId; + using Weight = typename FromArc::Weight; + + explicit RandGenVisitor(MutableFst *ofst) : ofst_(ofst) {} + + void InitVisit(const Fst &ifst) { + ifst_ = &ifst; + ofst_->DeleteStates(); + ofst_->SetInputSymbols(ifst.InputSymbols()); + ofst_->SetOutputSymbols(ifst.OutputSymbols()); + if (ifst.Properties(kError, false)) ofst_->SetProperties(kError, kError); + path_.clear(); + } + + constexpr bool InitState(StateId, StateId) const { return true; } + + bool TreeArc(StateId, const ToArc &arc) { + if (ifst_->Final(arc.nextstate) == Weight::Zero()) { + path_.push_back(arc); + } else { + OutputPath(); + } + return true; + } + + bool BackArc(StateId, const FromArc &) { + FSTERROR() << "RandGenVisitor: cyclic input"; + ofst_->SetProperties(kError, kError); + return false; + } + + bool ForwardOrCrossArc(StateId, const FromArc &) { + OutputPath(); + return true; + } + + void FinishState(StateId s, StateId p, const FromArc *) { + if (p != kNoStateId && ifst_->Final(s) == Weight::Zero()) path_.pop_back(); + } + + void FinishVisit() {} + + private: + void OutputPath() { + if (ofst_->Start() == kNoStateId) { + const auto start = ofst_->AddState(); + ofst_->SetStart(start); + } + auto src = ofst_->Start(); + for (size_t i = 0; i < path_.size(); ++i) { + const auto dest = ofst_->AddState(); + const ToArc arc(path_[i].ilabel, path_[i].olabel, Weight::One(), dest); + ofst_->AddArc(src, arc); + src = dest; + } + ofst_->SetFinal(src, Weight::One()); + } + + const Fst *ifst_; + MutableFst *ofst_; + std::vector path_; + + RandGenVisitor(const RandGenVisitor &) = delete; + RandGenVisitor &operator=(const RandGenVisitor &) = delete; +}; + +} // namespace internal + +// Randomly generate paths through an FST; details controlled by +// RandGenOptions. +template +void RandGen(const Fst &ifst, MutableFst *ofst, + const RandGenOptions &opts) { + using State = typename ToArc::StateId; + using Weight = typename ToArc::Weight; + using Sampler = ArcSampler; + auto *sampler = new Sampler(ifst, opts.selector, opts.max_length); + RandGenFstOptions fopts(CacheOptions(true, 0), sampler, opts.npath, + opts.weighted, opts.remove_total_weight); + RandGenFst rfst(ifst, fopts); + if (opts.weighted) { + *ofst = rfst; + } else { + internal::RandGenVisitor rand_visitor(ofst); + DfsVisit(rfst, &rand_visitor); + } +} + +// Randomly generate a path through an FST with the uniform distribution +// over the transitions. +template +void RandGen(const Fst &ifst, MutableFst *ofst) { + const UniformArcSelector uniform_selector; + RandGenOptions> opts(uniform_selector); + RandGen(ifst, ofst, opts); +} + +} // namespace fst + +#endif // FST_RANDGEN_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/rational.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/rational.h new file mode 100644 index 0000000000..5a9e6024f7 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/rational.h @@ -0,0 +1,307 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// An FST implementation and base interface for delayed unions, concatenations, +// and closures. + +#ifndef FST_RATIONAL_H_ +#define FST_RATIONAL_H_ + +#include +#include +#include + +#include +#include +#include + + +namespace fst { + +using RationalFstOptions = CacheOptions; + +// This specifies whether to add the empty string. +enum ClosureType { + CLOSURE_STAR = 0, // Add the empty string. + CLOSURE_PLUS = 1 // Don't add the empty string. +}; + +template +class RationalFst; + +template +void Union(RationalFst *fst1, const Fst &fst2); + +template +void Concat(RationalFst *fst1, const Fst &fst2); + +template +void Concat(const Fst &fst1, RationalFst *fst2); + +template +void Closure(RationalFst *fst, ClosureType closure_type); + +namespace internal { + +// Implementation class for delayed unions, concatenations and closures. +template +class RationalFstImpl : public FstImpl { + public: + using Arc = A; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using FstImpl::SetType; + using FstImpl::SetProperties; + using FstImpl::WriteHeader; + using FstImpl::SetInputSymbols; + using FstImpl::SetOutputSymbols; + + explicit RationalFstImpl(const RationalFstOptions &opts) + : nonterminals_(0), replace_options_(opts, 0) { + SetType("rational"); + fst_tuples_.push_back(std::make_pair(0, nullptr)); + } + + RationalFstImpl(const RationalFstImpl &impl) + : rfst_(impl.rfst_), + nonterminals_(impl.nonterminals_), + replace_(impl.replace_ ? impl.replace_->Copy(true) : nullptr), + replace_options_(impl.replace_options_) { + SetType("rational"); + fst_tuples_.reserve(impl.fst_tuples_.size()); + for (const auto &pair : impl.fst_tuples_) { + fst_tuples_.emplace_back(pair.first, + pair.second ? pair.second->Copy(true) : nullptr); + } + } + + ~RationalFstImpl() override { + for (auto &tuple : fst_tuples_) delete tuple.second; + } + + StateId Start() { return Replace()->Start(); } + + Weight Final(StateId s) { return Replace()->Final(s); } + + size_t NumArcs(StateId s) { return Replace()->NumArcs(s); } + + size_t NumInputEpsilons(StateId s) { return Replace()->NumInputEpsilons(s); } + + size_t NumOutputEpsilons(StateId s) { + return Replace()->NumOutputEpsilons(s); + } + + uint64 Properties() const override { return Properties(kFstProperties); } + + // Sets error if found, and returns other FST impl properties. + uint64 Properties(uint64 mask) const override { + if ((mask & kError) && Replace()->Properties(kError, false)) { + SetProperties(kError, kError); + } + return FstImpl::Properties(mask); + } + + // Implementation of UnionFst(fst1, fst2). + void InitUnion(const Fst &fst1, const Fst &fst2) { + replace_.reset(); + const auto props1 = fst1.Properties(kFstProperties, false); + const auto props2 = fst2.Properties(kFstProperties, false); + SetInputSymbols(fst1.InputSymbols()); + SetOutputSymbols(fst1.OutputSymbols()); + rfst_.AddState(); + rfst_.AddState(); + rfst_.SetStart(0); + rfst_.SetFinal(1, Weight::One()); + rfst_.SetInputSymbols(fst1.InputSymbols()); + rfst_.SetOutputSymbols(fst1.OutputSymbols()); + nonterminals_ = 2; + rfst_.AddArc(0, Arc(0, -1, Weight::One(), 1)); + rfst_.AddArc(0, Arc(0, -2, Weight::One(), 1)); + fst_tuples_.push_back(std::make_pair(-1, fst1.Copy())); + fst_tuples_.push_back(std::make_pair(-2, fst2.Copy())); + SetProperties(UnionProperties(props1, props2, true), kCopyProperties); + } + + // Implementation of ConcatFst(fst1, fst2). + void InitConcat(const Fst &fst1, const Fst &fst2) { + replace_.reset(); + const auto props1 = fst1.Properties(kFstProperties, false); + const auto props2 = fst2.Properties(kFstProperties, false); + SetInputSymbols(fst1.InputSymbols()); + SetOutputSymbols(fst1.OutputSymbols()); + rfst_.AddState(); + rfst_.AddState(); + rfst_.AddState(); + rfst_.SetStart(0); + rfst_.SetFinal(2, Weight::One()); + rfst_.SetInputSymbols(fst1.InputSymbols()); + rfst_.SetOutputSymbols(fst1.OutputSymbols()); + nonterminals_ = 2; + rfst_.AddArc(0, Arc(0, -1, Weight::One(), 1)); + rfst_.AddArc(1, Arc(0, -2, Weight::One(), 2)); + fst_tuples_.push_back(std::make_pair(-1, fst1.Copy())); + fst_tuples_.push_back(std::make_pair(-2, fst2.Copy())); + SetProperties(ConcatProperties(props1, props2, true), kCopyProperties); + } + + // Implementation of ClosureFst(fst, closure_type). + void InitClosure(const Fst &fst, ClosureType closure_type) { + replace_.reset(); + const auto props = fst.Properties(kFstProperties, false); + SetInputSymbols(fst.InputSymbols()); + SetOutputSymbols(fst.OutputSymbols()); + if (closure_type == CLOSURE_STAR) { + rfst_.AddState(); + rfst_.SetStart(0); + rfst_.SetFinal(0, Weight::One()); + rfst_.AddArc(0, Arc(0, -1, Weight::One(), 0)); + } else { + rfst_.AddState(); + rfst_.AddState(); + rfst_.SetStart(0); + rfst_.SetFinal(1, Weight::One()); + rfst_.AddArc(0, Arc(0, -1, Weight::One(), 1)); + rfst_.AddArc(1, Arc(0, 0, Weight::One(), 0)); + } + rfst_.SetInputSymbols(fst.InputSymbols()); + rfst_.SetOutputSymbols(fst.OutputSymbols()); + fst_tuples_.push_back(std::make_pair(-1, fst.Copy())); + nonterminals_ = 1; + SetProperties(ClosureProperties(props, closure_type == CLOSURE_STAR, true), + kCopyProperties); + } + + // Implementation of Union(Fst &, RationalFst *). + void AddUnion(const Fst &fst) { + replace_.reset(); + const auto props1 = FstImpl::Properties(); + const auto props2 = fst.Properties(kFstProperties, false); + VectorFst afst; + afst.AddState(); + afst.AddState(); + afst.SetStart(0); + afst.SetFinal(1, Weight::One()); + ++nonterminals_; + afst.AddArc(0, Arc(0, -nonterminals_, Weight::One(), 1)); + Union(&rfst_, afst); + fst_tuples_.push_back(std::make_pair(-nonterminals_, fst.Copy())); + SetProperties(UnionProperties(props1, props2, true), kCopyProperties); + } + + // Implementation of Concat(Fst &, RationalFst *). + void AddConcat(const Fst &fst, bool append) { + replace_.reset(); + const auto props1 = FstImpl::Properties(); + const auto props2 = fst.Properties(kFstProperties, false); + VectorFst afst; + afst.AddState(); + afst.AddState(); + afst.SetStart(0); + afst.SetFinal(1, Weight::One()); + ++nonterminals_; + afst.AddArc(0, Arc(0, -nonterminals_, Weight::One(), 1)); + if (append) { + Concat(&rfst_, afst); + } else { + Concat(afst, &rfst_); + } + fst_tuples_.push_back(std::make_pair(-nonterminals_, fst.Copy())); + SetProperties(ConcatProperties(props1, props2, true), kCopyProperties); + } + + // Implementation of Closure(RationalFst *, closure_type). + void AddClosure(ClosureType closure_type) { + replace_.reset(); + const auto props = FstImpl::Properties(); + Closure(&rfst_, closure_type); + SetProperties(ClosureProperties(props, closure_type == CLOSURE_STAR, true), + kCopyProperties); + } + + // Returns the underlying ReplaceFst, preserving ownership of the underlying + // object. + ReplaceFst *Replace() const { + if (!replace_) { + fst_tuples_[0].second = rfst_.Copy(); + replace_.reset(new ReplaceFst(fst_tuples_, replace_options_)); + } + return replace_.get(); + } + + private: + // Rational topology machine, using negative non-terminals. + VectorFst rfst_; + // Number of nonterminals used. + Label nonterminals_; + // Contains the nonterminals and their corresponding FSTs. + mutable std::vector *>> fst_tuples_; + // Underlying ReplaceFst. + mutable std::unique_ptr> replace_; + const ReplaceFstOptions replace_options_; +}; + +} // namespace internal + +// Parent class for the delayed rational operations (union, concatenation, and +// closure). This class attaches interface to implementation and handles +// reference counting, delegating most methods to ImplToFst. +template +class RationalFst : public ImplToFst> { + public: + using Arc = A; + using StateId = typename Arc::StateId; + + using Impl = internal::RationalFstImpl; + + friend class StateIterator>; + friend class ArcIterator>; + friend void Union<>(RationalFst *fst1, const Fst &fst2); + friend void Concat<>(RationalFst *fst1, const Fst &fst2); + friend void Concat<>(const Fst &fst1, RationalFst *fst2); + friend void Closure<>(RationalFst *fst, ClosureType closure_type); + + void InitStateIterator(StateIteratorData *data) const override { + GetImpl()->Replace()->InitStateIterator(data); + } + + void InitArcIterator(StateId s, ArcIteratorData *data) const override { + GetImpl()->Replace()->InitArcIterator(s, data); + } + + protected: + using ImplToFst::GetImpl; + + explicit RationalFst(const RationalFstOptions &opts = RationalFstOptions()) + : ImplToFst(std::make_shared(opts)) {} + + // See Fst<>::Copy() for doc. + RationalFst(const RationalFst &fst, bool safe = false) + : ImplToFst(fst, safe) {} + + private: + RationalFst &operator=(const RationalFst &) = delete; +}; + +// Specialization for RationalFst. +template +class StateIterator> : public StateIterator> { + public: + explicit StateIterator(const RationalFst &fst) + : StateIterator>(*(fst.GetImpl()->Replace())) {} +}; + +// Specialization for RationalFst. +template +class ArcIterator> : public CacheArcIterator> { + public: + using StateId = typename Arc::StateId; + + ArcIterator(const RationalFst &fst, StateId s) + : ArcIterator>(*(fst.GetImpl()->Replace()), s) {} +}; + +} // namespace fst + +#endif // FST_RATIONAL_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/register.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/register.h new file mode 100644 index 0000000000..2d1a6ea770 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/register.h @@ -0,0 +1,115 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Classes for registering derived FST for generic reading. + +#ifndef FST_REGISTER_H_ +#define FST_REGISTER_H_ + +#include +#include + + +#include +#include +#include + + +#include +#include + +namespace fst { + +template +class Fst; + +struct FstReadOptions; + +// This class represents a single entry in a FstRegister +template +struct FstRegisterEntry { + using Reader = Fst *(*)(std::istream &istrm, const FstReadOptions &opts); + using Converter = Fst *(*)(const Fst &fst); + + Reader reader; + Converter converter; + + explicit FstRegisterEntry(Reader reader = nullptr, + Converter converter = nullptr) + : reader(reader), converter(converter) {} +}; + +// This class maintains the correspondence between a string describing +// an FST type, and its reader and converter. +template +class FstRegister + : public GenericRegister, FstRegister> { + public: + using Reader = typename FstRegisterEntry::Reader; + using Converter = typename FstRegisterEntry::Converter; + + const Reader GetReader(const string &type) const { + return this->GetEntry(type).reader; + } + + const Converter GetConverter(const string &type) const { + return this->GetEntry(type).converter; + } + + protected: + string ConvertKeyToSoFilename(const string &key) const override { + string legal_type(key); + ConvertToLegalCSymbol(&legal_type); + return legal_type + "-fst.so"; + } +}; + +// This class registers an FST type for generic reading and creating. +// The type must have a default constructor and a copy constructor from +// Fst. +template +class FstRegisterer : public GenericRegisterer> { + public: + using Arc = typename FST::Arc; + using Entry = typename FstRegister::Entry; + using Reader = typename FstRegister::Reader; + + FstRegisterer() + : GenericRegisterer>(FST().Type(), + BuildEntry()) {} + + private: + static Fst *ReadGeneric( + std::istream &strm, const FstReadOptions &opts) { + static_assert(std::is_base_of, FST>::value, + "FST class does not inherit from Fst"); + return FST::Read(strm, opts); + } + + static Entry BuildEntry() { + return Entry(&ReadGeneric, &FstRegisterer::Convert); + } + + static Fst *Convert(const Fst &fst) { return new FST(fst); } +}; + +// Convenience macro to generate static FstRegisterer instance. +#define REGISTER_FST(FST, Arc) \ + static fst::FstRegisterer> FST##_##Arc##_registerer + +// Converts an FST to the specified type. +template +Fst *Convert(const Fst &fst, const string &fst_type) { + auto *reg = FstRegister::GetRegister(); + const auto converter = reg->GetConverter(fst_type); + if (!converter) { + FSTERROR() << "Fst::Convert: Unknown FST type " << fst_type << " (arc type " + << Arc::Type() << ")"; + return nullptr; + } + return converter(fst); +} + +} // namespace fst + +#endif // FST_REGISTER_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/relabel.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/relabel.h new file mode 100644 index 0000000000..3d73184e80 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/relabel.h @@ -0,0 +1,478 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Functions and classes to relabel an FST (either on input or output). + +#ifndef FST_RELABEL_H_ +#define FST_RELABEL_H_ + +#include +#include +#include +#include + +#include + +#include +#include + + +#include + +namespace fst { + +// Relabels either the input labels or output labels. The old to +// new labels are specified using a vector of std::pair. +// Any label associations not specified are assumed to be identity +// mapping. The destination labels must be valid labels (e.g., not kNoLabel). +template +void Relabel( + MutableFst *fst, + const std::vector> + &ipairs, + const std::vector> + &opairs) { + using Label = typename Arc::Label; + const auto props = fst->Properties(kFstProperties, false); + // Constructs label-to-label maps. + std::unordered_map input_map; + for (auto &ipair : ipairs) input_map[ipair.first] = ipair.second; + std::unordered_map output_map; + for (auto &opair : opairs) output_map[opair.first] = opair.second; + for (StateIterator> siter(*fst); !siter.Done(); + siter.Next()) { + for (MutableArcIterator> aiter(fst, siter.Value()); + !aiter.Done(); aiter.Next()) { + auto arc = aiter.Value(); + // Relabels input. + auto it = input_map.find(arc.ilabel); + if (it != input_map.end()) { + if (it->second == kNoLabel) { + FSTERROR() << "Input symbol ID " << arc.ilabel + << " missing from target vocabulary"; + fst->SetProperties(kError, kError); + return; + } + arc.ilabel = it->second; + } + // Relabels output. + it = output_map.find(arc.olabel); + if (it != output_map.end()) { + if (it->second == kNoLabel) { + FSTERROR() << "Output symbol id " << arc.olabel + << " missing from target vocabulary"; + fst->SetProperties(kError, kError); + return; + } + arc.olabel = it->second; + } + aiter.SetValue(arc); + } + } + fst->SetProperties(RelabelProperties(props), kFstProperties); +} + +// Relabels either the input labels or output labels. The old to +// new labels are specified using pairs of old and new symbol tables. +// The tables must contain (at least) all labels on the appropriate side of the +// FST. If the 'unknown_i(o)symbol' is non-empty, it is used to label any +// missing symbol in new_i(o)symbols table. +template +void Relabel(MutableFst *fst, + const SymbolTable *old_isymbols, const SymbolTable *new_isymbols, + const string &unknown_isymbol, bool attach_new_isymbols, + const SymbolTable *old_osymbols, const SymbolTable *new_osymbols, + const string &unknown_osymbol, bool attach_new_osymbols) { + using Label = typename Arc::Label; + // Constructs vectors of input-side label pairs. + std::vector> ipairs; + if (old_isymbols && new_isymbols) { + size_t num_missing_syms = 0; + Label unknown_ilabel = kNoLabel; + if (!unknown_isymbol.empty()) { + unknown_ilabel = new_isymbols->Find(unknown_isymbol); + if (unknown_ilabel == kNoLabel) { + VLOG(1) << "Input symbol '" << unknown_isymbol + << "' missing from target symbol table"; + ++num_missing_syms; + } + } + + for (SymbolTableIterator siter(*old_isymbols); !siter.Done(); + siter.Next()) { + const auto old_index = siter.Value(); + const auto symbol = siter.Symbol(); + auto new_index = new_isymbols->Find(siter.Symbol()); + if (new_index == kNoLabel) { + if (unknown_ilabel != kNoLabel) { + new_index = unknown_ilabel; + } else { + VLOG(1) << "Input symbol ID " << old_index << " symbol '" << symbol + << "' missing from target symbol table"; + ++num_missing_syms; + } + } + ipairs.push_back(std::make_pair(old_index, new_index)); + } + if (num_missing_syms > 0) { + LOG(WARNING) << "Target symbol table missing: " << num_missing_syms + << " input symbols"; + } + if (attach_new_isymbols) fst->SetInputSymbols(new_isymbols); + } + // Constructs vectors of output-side label pairs. + std::vector> opairs; + if (old_osymbols && new_osymbols) { + size_t num_missing_syms = 0; + Label unknown_olabel = kNoLabel; + if (!unknown_osymbol.empty()) { + unknown_olabel = new_osymbols->Find(unknown_osymbol); + if (unknown_olabel == kNoLabel) { + VLOG(1) << "Output symbol '" << unknown_osymbol + << "' missing from target symbol table"; + ++num_missing_syms; + } + } + + for (SymbolTableIterator siter(*old_osymbols); !siter.Done(); + siter.Next()) { + const auto old_index = siter.Value(); + const auto symbol = siter.Symbol(); + auto new_index = new_osymbols->Find(siter.Symbol()); + if (new_index == kNoLabel) { + if (unknown_olabel != kNoLabel) { + new_index = unknown_olabel; + } else { + VLOG(1) << "Output symbol ID " << old_index << " symbol '" << symbol + << "' missing from target symbol table"; + ++num_missing_syms; + } + } + opairs.push_back(std::make_pair(old_index, new_index)); + } + if (num_missing_syms > 0) { + LOG(WARNING) << "Target symbol table missing: " << num_missing_syms + << " output symbols"; + } + if (attach_new_osymbols) fst->SetOutputSymbols(new_osymbols); + } + // Calls relabel using vector of relabel pairs. + Relabel(fst, ipairs, opairs); +} + +// Same as previous but no special allowance for unknown symbols. Kept +// for backward compat. +template +void Relabel(MutableFst *fst, const SymbolTable *old_isymbols, + const SymbolTable *new_isymbols, bool attach_new_isymbols, + const SymbolTable *old_osymbols, const SymbolTable *new_osymbols, + bool attach_new_osymbols) { + Relabel(fst, + old_isymbols, new_isymbols, "" /* no unknown isymbol */, + attach_new_isymbols, + old_osymbols, new_osymbols, "" /* no unknown ioymbol */, + attach_new_osymbols); +} + + +// Relabels either the input labels or output labels. The old to +// new labels are specified using symbol tables. Any label associations not +// specified are assumed to be identity mapping. +template +void Relabel(MutableFst *fst, const SymbolTable *new_isymbols, + const SymbolTable *new_osymbols) { + Relabel(fst, fst->InputSymbols(), new_isymbols, true, fst->OutputSymbols(), + new_osymbols, true); +} + +using RelabelFstOptions = CacheOptions; + +template +class RelabelFst; + +namespace internal { + +// Relabels an FST from one symbol set to another. Relabeling can either be on +// input or output space. RelabelFst implements a delayed version of the +// relabel. Arcs are relabeled on the fly and not cached; i.e., each request is +// recomputed. +template +class RelabelFstImpl : public CacheImpl { + public: + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using Store = DefaultCacheStore; + using State = typename Store::State; + + using FstImpl::SetType; + using FstImpl::SetProperties; + using FstImpl::WriteHeader; + using FstImpl::SetInputSymbols; + using FstImpl::SetOutputSymbols; + + using CacheImpl::PushArc; + using CacheImpl::HasArcs; + using CacheImpl::HasFinal; + using CacheImpl::HasStart; + using CacheImpl::SetArcs; + using CacheImpl::SetFinal; + using CacheImpl::SetStart; + + friend class StateIterator>; + + RelabelFstImpl(const Fst &fst, + const std::vector> &ipairs, + const std::vector> &opairs, + const RelabelFstOptions &opts) + : CacheImpl(opts), + fst_(fst.Copy()), + relabel_input_(false), + relabel_output_(false) { + SetProperties(RelabelProperties(fst.Properties(kCopyProperties, false))); + SetType("relabel"); + // Creates input label map. + if (!ipairs.empty()) { + for (auto &ipair : ipairs) input_map_[ipair.first] = ipair.second; + relabel_input_ = true; + } + // Creates output label map. + if (!opairs.empty()) { + for (auto &opair : opairs) output_map_[opair.first] = opair.second; + relabel_output_ = true; + } + } + + RelabelFstImpl(const Fst &fst, const SymbolTable *old_isymbols, + const SymbolTable *new_isymbols, + const SymbolTable *old_osymbols, + const SymbolTable *new_osymbols, const RelabelFstOptions &opts) + : CacheImpl(opts), + fst_(fst.Copy()), + relabel_input_(false), + relabel_output_(false) { + SetType("relabel"); + SetProperties(RelabelProperties(fst.Properties(kCopyProperties, false))); + SetInputSymbols(old_isymbols); + SetOutputSymbols(old_osymbols); + if (old_isymbols && new_isymbols && + old_isymbols->LabeledCheckSum() != new_isymbols->LabeledCheckSum()) { + for (SymbolTableIterator siter(*old_isymbols); !siter.Done(); + siter.Next()) { + input_map_[siter.Value()] = new_isymbols->Find(siter.Symbol()); + } + SetInputSymbols(new_isymbols); + relabel_input_ = true; + } + if (old_osymbols && new_osymbols && + old_osymbols->LabeledCheckSum() != new_osymbols->LabeledCheckSum()) { + for (SymbolTableIterator siter(*old_osymbols); !siter.Done(); + siter.Next()) { + output_map_[siter.Value()] = new_osymbols->Find(siter.Symbol()); + } + SetOutputSymbols(new_osymbols); + relabel_output_ = true; + } + } + + RelabelFstImpl(const RelabelFstImpl &impl) + : CacheImpl(impl), + fst_(impl.fst_->Copy(true)), + input_map_(impl.input_map_), + output_map_(impl.output_map_), + relabel_input_(impl.relabel_input_), + relabel_output_(impl.relabel_output_) { + SetType("relabel"); + SetProperties(impl.Properties(), kCopyProperties); + SetInputSymbols(impl.InputSymbols()); + SetOutputSymbols(impl.OutputSymbols()); + } + + StateId Start() { + if (!HasStart()) SetStart(fst_->Start()); + return CacheImpl::Start(); + } + + Weight Final(StateId s) { + if (!HasFinal(s)) SetFinal(s, fst_->Final(s)); + return CacheImpl::Final(s); + } + + size_t NumArcs(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumArcs(s); + } + + size_t NumInputEpsilons(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumInputEpsilons(s); + } + + size_t NumOutputEpsilons(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumOutputEpsilons(s); + } + + uint64 Properties() const override { return Properties(kFstProperties); } + + // Sets error if found, and returns other FST impl properties. + uint64 Properties(uint64 mask) const override { + if ((mask & kError) && fst_->Properties(kError, false)) { + SetProperties(kError, kError); + } + return FstImpl::Properties(mask); + } + + void InitArcIterator(StateId s, ArcIteratorData *data) { + if (!HasArcs(s)) Expand(s); + CacheImpl::InitArcIterator(s, data); + } + + void Expand(StateId s) { + for (ArcIterator> aiter(*fst_, s); !aiter.Done(); aiter.Next()) { + auto arc = aiter.Value(); + if (relabel_input_) { + auto it = input_map_.find(arc.ilabel); + if (it != input_map_.end()) arc.ilabel = it->second; + } + if (relabel_output_) { + auto it = output_map_.find(arc.olabel); + if (it != output_map_.end()) { + arc.olabel = it->second; + } + } + PushArc(s, arc); + } + SetArcs(s); + } + + private: + std::unique_ptr> fst_; + + std::unordered_map input_map_; + std::unordered_map output_map_; + bool relabel_input_; + bool relabel_output_; +}; + +} // namespace internal + +// This class attaches interface to implementation and handles +// reference counting, delegating most methods to ImplToFst. +template +class RelabelFst : public ImplToFst> { + public: + using Arc = A; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using Store = DefaultCacheStore; + using State = typename Store::State; + using Impl = internal::RelabelFstImpl; + + friend class ArcIterator>; + friend class StateIterator>; + + RelabelFst(const Fst &fst, + const std::vector> &ipairs, + const std::vector> &opairs, + const RelabelFstOptions &opts = RelabelFstOptions()) + : ImplToFst(std::make_shared(fst, ipairs, opairs, opts)) {} + + RelabelFst(const Fst &fst, const SymbolTable *new_isymbols, + const SymbolTable *new_osymbols, + const RelabelFstOptions &opts = RelabelFstOptions()) + : ImplToFst( + std::make_shared(fst, fst.InputSymbols(), new_isymbols, + fst.OutputSymbols(), new_osymbols, opts)) {} + + RelabelFst(const Fst &fst, const SymbolTable *old_isymbols, + const SymbolTable *new_isymbols, const SymbolTable *old_osymbols, + const SymbolTable *new_osymbols, + const RelabelFstOptions &opts = RelabelFstOptions()) + : ImplToFst(std::make_shared(fst, old_isymbols, new_isymbols, + old_osymbols, new_osymbols, + opts)) {} + + // See Fst<>::Copy() for doc. + RelabelFst(const RelabelFst &fst, bool safe = false) + : ImplToFst(fst, safe) {} + + // Gets a copy of this RelabelFst. See Fst<>::Copy() for further doc. + RelabelFst *Copy(bool safe = false) const override { + return new RelabelFst(*this, safe); + } + + void InitStateIterator(StateIteratorData *data) const override; + + void InitArcIterator(StateId s, ArcIteratorData *data) const override { + return GetMutableImpl()->InitArcIterator(s, data); + } + + private: + using ImplToFst::GetImpl; + using ImplToFst::GetMutableImpl; + + RelabelFst &operator=(const RelabelFst &) = delete; +}; + +// Specialization for RelabelFst. +template +class StateIterator> : public StateIteratorBase { + public: + using StateId = typename Arc::StateId; + + explicit StateIterator(const RelabelFst &fst) + : impl_(fst.GetImpl()), siter_(*impl_->fst_), s_(0) {} + + bool Done() const final { return siter_.Done(); } + + StateId Value() const final { return s_; } + + void Next() final { + if (!siter_.Done()) { + ++s_; + siter_.Next(); + } + } + + void Reset() final { + s_ = 0; + siter_.Reset(); + } + + private: + const internal::RelabelFstImpl* impl_; + StateIterator> siter_; + StateId s_; + + StateIterator(const StateIterator &) = delete; + StateIterator &operator=(const StateIterator &) = delete; +}; + +// Specialization for RelabelFst. +template +class ArcIterator> : public CacheArcIterator> { + public: + using StateId = typename Arc::StateId; + + ArcIterator(const RelabelFst &fst, StateId s) + : CacheArcIterator>(fst.GetMutableImpl(), s) { + if (!fst.GetImpl()->HasArcs(s)) fst.GetMutableImpl()->Expand(s); + } +}; + +template +inline void RelabelFst::InitStateIterator( + StateIteratorData *data) const { + data->base = new StateIterator>(*this); +} + +// Useful alias when using StdArc. +using StdRelabelFst = RelabelFst; + +} // namespace fst + +#endif // FST_RELABEL_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/replace-util.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/replace-util.h new file mode 100644 index 0000000000..f4e15621ae --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/replace-util.h @@ -0,0 +1,629 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Utility classes for the recursive replacement of FSTs (RTNs). + +#ifndef FST_REPLACE_UTIL_H_ +#define FST_REPLACE_UTIL_H_ + +#include +#include +#include +#include + +#include + +#include +#include +#include +#include + + +namespace fst { + +// This specifies what labels to output on the call or return arc. Note that +// REPLACE_LABEL_INPUT and REPLACE_LABEL_OUTPUT will produce transducers when +// applied to acceptors. +enum ReplaceLabelType { + // Epsilon labels on both input and output. + REPLACE_LABEL_NEITHER = 1, + // Non-epsilon labels on input and epsilon on output. + REPLACE_LABEL_INPUT = 2, + // Epsilon on input and non-epsilon on output. + REPLACE_LABEL_OUTPUT = 3, + // Non-epsilon labels on both input and output. + REPLACE_LABEL_BOTH = 4 +}; + +// By default ReplaceUtil will copy the input label of the replace arc. +// The call_label_type and return_label_type options specify how to manage +// the labels of the call arc and the return arc of the replace FST +struct ReplaceUtilOptions { + int64 root; // Root rule for expansion. + ReplaceLabelType call_label_type; // How to label call arc. + ReplaceLabelType return_label_type; // How to label return arc. + int64 return_label; // Label to put on return arc. + + explicit ReplaceUtilOptions( + int64 root = kNoLabel, + ReplaceLabelType call_label_type = REPLACE_LABEL_INPUT, + ReplaceLabelType return_label_type = REPLACE_LABEL_NEITHER, + int64 return_label = 0) + : root(root), + call_label_type(call_label_type), + return_label_type(return_label_type), + return_label(return_label) {} + + // For backwards compatibility. + ReplaceUtilOptions(int64 root, bool epsilon_replace_arc) + : ReplaceUtilOptions(root, + epsilon_replace_arc ? REPLACE_LABEL_NEITHER + : REPLACE_LABEL_INPUT) {} +}; + +// Every non-terminal on a path appears as the first label on that path in every +// FST associated with a given SCC of the replace dependency graph. This would +// be true if the SCC were formed from left-linear grammar rules. +constexpr uint8 kReplaceSCCLeftLinear = 0x01; +// Every non-terminal on a path appears as the final label on that path in every +// FST associated with a given SCC of the replace dependency graph. This would +// be true if the SCC were formed from right-linear grammar rules. +constexpr uint8 kReplaceSCCRightLinear = 0x02; +// The SCC in the replace dependency graph has more than one state or a +// self-loop. +constexpr uint8 kReplaceSCCNonTrivial = 0x04; + +// Defined in replace.h. +template +void Replace( + const std::vector *>> &, + MutableFst *, const ReplaceUtilOptions &); + +// Utility class for the recursive replacement of FSTs (RTNs). The user provides +// a set of label/FST pairs at construction. These are used by methods for +// testing cyclic dependencies and connectedness and doing RTN connection and +// specific FST replacement by label or for various optimization properties. The +// modified results can be obtained with the GetFstPairs() or +// GetMutableFstPairs() methods. +template +class ReplaceUtil { + public: + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using FstPair = std::pair *>; + using MutableFstPair = std::pair *>; + using NonTerminalHash = std::unordered_map; + + // Constructs from mutable FSTs; FST ownership is given to ReplaceUtil. + ReplaceUtil(const std::vector &fst_pairs, + const ReplaceUtilOptions &opts); + + // Constructs from FSTs; FST ownership is retained by caller. + ReplaceUtil(const std::vector &fst_pairs, + const ReplaceUtilOptions &opts); + + // Constructs from ReplaceFst internals; FST ownership is retained by caller. + ReplaceUtil(const std::vector>> &fst_array, + const NonTerminalHash &nonterminal_hash, + const ReplaceUtilOptions &opts); + + ~ReplaceUtil() { + for (Label i = 0; i < fst_array_.size(); ++i) delete fst_array_[i]; + } + + // True if the non-terminal dependencies are cyclic. Cyclic dependencies will + // result in an unexpandable FST. + bool CyclicDependencies() const { + GetDependencies(false); + return depprops_ & kCyclic; + } + + // Returns the strongly-connected component ID in the dependency graph of the + // replace FSTS. + StateId SCC(Label label) const { + GetDependencies(false); + const auto it = nonterminal_hash_.find(label); + if (it == nonterminal_hash_.end()) return kNoStateId; + return depscc_[it->second]; + } + + // Returns properties for the strongly-connected component in the dependency + // graph of the replace FSTs. If the SCC is kReplaceSCCLeftLinear or + // kReplaceSCCRightLinear, that SCC can be represented as finite-state despite + // any cyclic dependencies, but not by the usual replacement operation (see + // fst/extensions/pdt/replace.h). + uint8 SCCProperties(StateId scc_id) { + GetSCCProperties(); + return depsccprops_[scc_id]; + } + + // Returns true if no useless FSTs, states or transitions are present in the + // RTN. + bool Connected() const { + GetDependencies(false); + uint64 props = kAccessible | kCoAccessible; + for (Label i = 0; i < fst_array_.size(); ++i) { + if (!fst_array_[i]) continue; + if (fst_array_[i]->Properties(props, true) != props || !depaccess_[i]) { + return false; + } + } + return true; + } + + // Removes useless FSTs, states and transitions from the RTN. + void Connect(); + + // Replaces FSTs specified by labels, unless there are cyclic dependencies. + void ReplaceLabels(const std::vector */> +class ReplaceFst + : public ImplToFst> { + public: + using Arc = A; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using StateTable = T; + using Store = CacheStore; + using State = typename CacheStore::State; + using Impl = internal::ReplaceFstImpl; + using CacheImpl = internal::CacheBaseImpl; + + using ImplToFst::Properties; + + friend class ArcIterator>; + friend class StateIterator>; + friend class ReplaceFstMatcher; + + ReplaceFst(const std::vector *>> &fst_array, + Label root) + : ImplToFst(std::make_shared( + fst_array, ReplaceFstOptions(root))) {} + + ReplaceFst(const std::vector *>> &fst_array, + const ReplaceFstOptions &opts) + : ImplToFst(std::make_shared(fst_array, opts)) {} + + // See Fst<>::Copy() for doc. + ReplaceFst(const ReplaceFst &fst, + bool safe = false) + : ImplToFst(fst, safe) {} + + // Get a copy of this ReplaceFst. See Fst<>::Copy() for further doc. + ReplaceFst *Copy( + bool safe = false) const override { + return new ReplaceFst(*this, safe); + } + + inline void InitStateIterator(StateIteratorData *data) const override; + + void InitArcIterator(StateId s, ArcIteratorData *data) const override { + GetMutableImpl()->InitArcIterator(s, data); + } + + MatcherBase *InitMatcher(MatchType match_type) const override { + if ((GetImpl()->ArcIteratorFlags() & kArcNoCache) && + ((match_type == MATCH_INPUT && Properties(kILabelSorted, false)) || + (match_type == MATCH_OUTPUT && Properties(kOLabelSorted, false)))) { + return new ReplaceFstMatcher + (this, match_type); + } else { + VLOG(2) << "Not using replace matcher"; + return nullptr; + } + } + + bool CyclicDependencies() const { return GetImpl()->CyclicDependencies(); } + + const StateTable &GetStateTable() const { + return *GetImpl()->GetStateTable(); + } + + const Fst &GetFst(Label nonterminal) const { + return *GetImpl()->GetFst(GetImpl()->GetFstId(nonterminal)); + } + + private: + using ImplToFst::GetImpl; + using ImplToFst::GetMutableImpl; + + ReplaceFst &operator=(const ReplaceFst &) = delete; +}; + +// Specialization for ReplaceFst. +template +class StateIterator> + : public CacheStateIterator> { + public: + explicit StateIterator(const ReplaceFst &fst) + : CacheStateIterator>( + fst, fst.GetMutableImpl()) {} +}; + +// Specialization for ReplaceFst, implementing optional caching. It is be used +// as follows: +// +// ReplaceFst replace; +// ArcIterator> aiter(replace, s); +// // Note: ArcIterator< Fst> is always a caching arc iterator. +// aiter.SetFlags(kArcNoCache, kArcNoCache); +// // Uses the arc iterator, no arc will be cached, no state will be expanded. +// // Arc flags can be used to decide which component of the arc need to be +// computed. +// aiter.SetFlags(kArcILabelValue, kArcValueFlags); +// // Wants the ilabel for this arc. +// aiter.Value(); // Does not compute the destination state. +// aiter.Next(); +// aiter.SetFlags(kArcNextStateValue, kArcNextStateValue); +// // Wants the ilabel and next state for this arc. +// aiter.Value(); // Does compute the destination state and inserts it +// // in the replace state table. +// // No additional arcs have been cached at this point. +template +class ArcIterator> { + public: + using StateId = typename Arc::StateId; + + using StateTuple = typename StateTable::StateTuple; + + ArcIterator(const ReplaceFst &fst, StateId s) + : fst_(fst), + s_(s), + pos_(0), + offset_(0), + flags_(kArcValueFlags), + arcs_(nullptr), + data_flags_(0), + final_flags_(0) { + cache_data_.ref_count = nullptr; + local_data_.ref_count = nullptr; + // If FST does not support optional caching, forces caching. + if (!(fst_.GetImpl()->ArcIteratorFlags() & kArcNoCache) && + !(fst_.GetImpl()->HasArcs(s_))) { + fst_.GetMutableImpl()->Expand(s_); + } + // If state is already cached, use cached arcs array. + if (fst_.GetImpl()->HasArcs(s_)) { + (fst_.GetImpl()) + ->internal::template CacheBaseImpl< + typename CacheStore::State, + CacheStore>::InitArcIterator(s_, &cache_data_); + num_arcs_ = cache_data_.narcs; + arcs_ = cache_data_.arcs; // arcs_ is a pointer to the cached arcs. + data_flags_ = kArcValueFlags; // All the arc member values are valid. + } else { // Otherwise delay decision until Value() is called. + tuple_ = fst_.GetImpl()->GetStateTable()->Tuple(s_); + if (tuple_.fst_state == kNoStateId) { + num_arcs_ = 0; + } else { + // The decision to cache or not to cache has been defered until Value() + // or + // SetFlags() is called. However, the arc iterator is set up now to be + // ready for non-caching in order to keep the Value() method simple and + // efficient. + const auto *rfst = fst_.GetImpl()->GetFst(tuple_.fst_id); + rfst->InitArcIterator(tuple_.fst_state, &local_data_); + // arcs_ is a pointer to the arcs in the underlying machine. + arcs_ = local_data_.arcs; + // Computes the final arc (but not its destination state) if a final arc + // is required. + bool has_final_arc = fst_.GetMutableImpl()->ComputeFinalArc( + tuple_, &final_arc_, kArcValueFlags & ~kArcNextStateValue); + // Sets the arc value flags that hold for final_arc_. + final_flags_ = kArcValueFlags & ~kArcNextStateValue; + // Computes the number of arcs. + num_arcs_ = local_data_.narcs; + if (has_final_arc) ++num_arcs_; + // Sets the offset between the underlying arc positions and the + // positions + // in the arc iterator. + offset_ = num_arcs_ - local_data_.narcs; + // Defers the decision to cache or not until Value() or SetFlags() is + // called. + data_flags_ = 0; + } + } + } + + ~ArcIterator() { + if (cache_data_.ref_count) --(*cache_data_.ref_count); + if (local_data_.ref_count) --(*local_data_.ref_count); + } + + void ExpandAndCache() const { + // TODO(allauzen): revisit this. + // fst_.GetImpl()->Expand(s_, tuple_, local_data_); + // (fst_.GetImpl())->CacheImpl*>::InitArcIterator(s_, + // &cache_data_); + // + fst_.InitArcIterator(s_, &cache_data_); // Expand and cache state. + arcs_ = cache_data_.arcs; // arcs_ is a pointer to the cached arcs. + data_flags_ = kArcValueFlags; // All the arc member values are valid. + offset_ = 0; // No offset. + } + + void Init() { + if (flags_ & kArcNoCache) { // If caching is disabled + // arcs_ is a pointer to the arcs in the underlying machine. + arcs_ = local_data_.arcs; + // Sets the arcs value flags that hold for arcs_. + data_flags_ = kArcWeightValue; + if (!fst_.GetMutableImpl()->EpsilonOnCallInput()) { + data_flags_ |= kArcILabelValue; + } + // Sets the offset between the underlying arc positions and the positions + // in the arc iterator. + offset_ = num_arcs_ - local_data_.narcs; + } else { + ExpandAndCache(); + } + } + + bool Done() const { return pos_ >= num_arcs_; } + + const Arc &Value() const { + // If data_flags_ is 0, non-caching was not requested. + if (!data_flags_) { + // TODO(allauzen): Revisit this. + if (flags_ & kArcNoCache) { + // Should never happen. + FSTERROR() << "ReplaceFst: Inconsistent arc iterator flags"; + } + ExpandAndCache(); + } + if (pos_ - offset_ >= 0) { // The requested arc is not the final arc. + const auto &arc = arcs_[pos_ - offset_]; + if ((data_flags_ & flags_) == (flags_ & kArcValueFlags)) { + // If the value flags match the recquired value flags then returns the + // arc. + return arc; + } else { + // Otherwise, compute the corresponding arc on-the-fly. + fst_.GetMutableImpl()->ComputeArc(tuple_, arc, &arc_, + flags_ & kArcValueFlags); + return arc_; + } + } else { // The requested arc is the final arc. + if ((final_flags_ & flags_) != (flags_ & kArcValueFlags)) { + // If the arc value flags that hold for the final arc do not match the + // requested value flags, then + // final_arc_ needs to be updated. + fst_.GetMutableImpl()->ComputeFinalArc(tuple_, &final_arc_, + flags_ & kArcValueFlags); + final_flags_ = flags_ & kArcValueFlags; + } + return final_arc_; + } + } + + void Next() { ++pos_; } + + size_t Position() const { return pos_; } + + void Reset() { pos_ = 0; } + + void Seek(size_t pos) { pos_ = pos; } + + uint32 Flags() const { return flags_; } + + void SetFlags(uint32 flags, uint32 mask) { + // Updates the flags taking into account what flags are supported + // by the FST. + flags_ &= ~mask; + flags_ |= (flags & fst_.GetImpl()->ArcIteratorFlags()); + // If non-caching is not requested (and caching has not already been + // performed), then flush data_flags_ to request caching during the next + // call to Value(). + if (!(flags_ & kArcNoCache) && data_flags_ != kArcValueFlags) { + if (!fst_.GetImpl()->HasArcs(s_)) data_flags_ = 0; + } + // If data_flags_ has been flushed but non-caching is requested before + // calling Value(), then set up the iterator for non-caching. + if ((flags & kArcNoCache) && (!data_flags_)) Init(); + } + + private: + const ReplaceFst &fst_; // Reference to the FST. + StateId s_; // State in the FST. + mutable StateTuple tuple_; // Tuple corresponding to state_. + + ssize_t pos_; // Current position. + mutable ssize_t offset_; // Offset between position in iterator and in arcs_. + ssize_t num_arcs_; // Number of arcs at state_. + uint32 flags_; // Behavorial flags for the arc iterator + mutable Arc arc_; // Memory to temporarily store computed arcs. + + mutable ArcIteratorData cache_data_; // Arc iterator data in cache. + mutable ArcIteratorData local_data_; // Arc iterator data in local FST. + + mutable const Arc *arcs_; // Array of arcs. + mutable uint32 data_flags_; // Arc value flags valid for data in arcs_. + mutable Arc final_arc_; // Final arc (when required). + mutable uint32 final_flags_; // Arc value flags valid for final_arc_. + + ArcIterator(const ArcIterator &) = delete; + ArcIterator &operator=(const ArcIterator &) = delete; +}; + +template +class ReplaceFstMatcher : public MatcherBase { + public: + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using FST = ReplaceFst; + using LocalMatcher = MultiEpsMatcher>>; + + using StateTuple = typename StateTable::StateTuple; + + // This makes a copy of the FST. + ReplaceFstMatcher(const ReplaceFst &fst, + MatchType match_type) + : owned_fst_(fst.Copy()), + fst_(*owned_fst_), + impl_(fst_.GetMutableImpl()), + s_(fst::kNoStateId), + match_type_(match_type), + current_loop_(false), + final_arc_(false), + loop_(kNoLabel, 0, Weight::One(), kNoStateId) { + if (match_type_ == fst::MATCH_OUTPUT) { + std::swap(loop_.ilabel, loop_.olabel); + } + InitMatchers(); + } + + // This doesn't copy the FST. + ReplaceFstMatcher(const ReplaceFst *fst, + MatchType match_type) + : fst_(*fst), + impl_(fst_.GetMutableImpl()), + s_(fst::kNoStateId), + match_type_(match_type), + current_loop_(false), + final_arc_(false), + loop_(kNoLabel, 0, Weight::One(), kNoStateId) { + if (match_type_ == fst::MATCH_OUTPUT) { + std::swap(loop_.ilabel, loop_.olabel); + } + InitMatchers(); + } + + // This makes a copy of the FST. + ReplaceFstMatcher( + const ReplaceFstMatcher &matcher, + bool safe = false) + : owned_fst_(matcher.fst_.Copy(safe)), + fst_(*owned_fst_), + impl_(fst_.GetMutableImpl()), + s_(fst::kNoStateId), + match_type_(matcher.match_type_), + current_loop_(false), + final_arc_(false), + loop_(fst::kNoLabel, 0, Weight::One(), fst::kNoStateId) { + if (match_type_ == fst::MATCH_OUTPUT) { + std::swap(loop_.ilabel, loop_.olabel); + } + InitMatchers(); + } + + // Creates a local matcher for each component FST in the RTN. LocalMatcher is + // a multi-epsilon wrapper matcher. MultiEpsilonMatcher is used to match each + // non-terminal arc, since these non-terminal + // turn into epsilons on recursion. + void InitMatchers() { + const auto &fst_array = impl_->fst_array_; + matcher_.resize(fst_array.size()); + for (Label i = 0; i < fst_array.size(); ++i) { + if (fst_array[i]) { + matcher_[i].reset( + new LocalMatcher(*fst_array[i], match_type_, kMultiEpsList)); + auto it = impl_->nonterminal_set_.begin(); + for (; it != impl_->nonterminal_set_.end(); ++it) { + matcher_[i]->AddMultiEpsLabel(*it); + } + } + } + } + + ReplaceFstMatcher *Copy( + bool safe = false) const override { + return new ReplaceFstMatcher(*this, safe); + } + + MatchType Type(bool test) const override { + if (match_type_ == MATCH_NONE) return match_type_; + const auto true_prop = + match_type_ == MATCH_INPUT ? kILabelSorted : kOLabelSorted; + const auto false_prop = + match_type_ == MATCH_INPUT ? kNotILabelSorted : kNotOLabelSorted; + const auto props = fst_.Properties(true_prop | false_prop, test); + if (props & true_prop) { + return match_type_; + } else if (props & false_prop) { + return MATCH_NONE; + } else { + return MATCH_UNKNOWN; + } + } + + const Fst &GetFst() const override { return fst_; } + + uint64 Properties(uint64 props) const override { return props; } + + // Sets the state from which our matching happens. + void SetState(StateId s) final { + if (s_ == s) return; + s_ = s; + tuple_ = impl_->GetStateTable()->Tuple(s_); + if (tuple_.fst_state == kNoStateId) { + done_ = true; + return; + } + // Gets current matcher, used for non-epsilon matching. + current_matcher_ = matcher_[tuple_.fst_id].get(); + current_matcher_->SetState(tuple_.fst_state); + loop_.nextstate = s_; + final_arc_ = false; + } + + // Searches for label from previous set state. If label == 0, first + // hallucinate an epsilon loop; otherwise use the underlying matcher to + // search for the label or epsilons. Note since the ReplaceFst recursion + // on non-terminal arcs causes epsilon transitions to be created we use + // MultiEpsilonMatcher to search for possible matches of non-terminals. If the + // component FST + // reaches a final state we also need to add the exiting final arc. + bool Find(Label label) final { + bool found = false; + label_ = label; + if (label_ == 0 || label_ == kNoLabel) { + // Computes loop directly, avoiding Replace::ComputeArc. + if (label_ == 0) { + current_loop_ = true; + found = true; + } + // Searches for matching multi-epsilons. + final_arc_ = impl_->ComputeFinalArc(tuple_, nullptr); + found = current_matcher_->Find(kNoLabel) || final_arc_ || found; + } else { + // Searches on a sub machine directly using sub machine matcher. + found = current_matcher_->Find(label_); + } + return found; + } + + bool Done() const final { + return !current_loop_ && !final_arc_ && current_matcher_->Done(); + } + + const Arc &Value() const final { + if (current_loop_) return loop_; + if (final_arc_) { + impl_->ComputeFinalArc(tuple_, &arc_); + return arc_; + } + const auto &component_arc = current_matcher_->Value(); + impl_->ComputeArc(tuple_, component_arc, &arc_); + return arc_; + } + + void Next() final { + if (current_loop_) { + current_loop_ = false; + return; + } + if (final_arc_) { + final_arc_ = false; + return; + } + current_matcher_->Next(); + } + + ssize_t Priority(StateId s) final { return fst_.NumArcs(s); } + + private: + std::unique_ptr> owned_fst_; + const ReplaceFst &fst_; + internal::ReplaceFstImpl *impl_; + LocalMatcher *current_matcher_; + std::vector> matcher_; + StateId s_; // Current state. + Label label_; // Current label. + MatchType match_type_; // Supplied by caller. + mutable bool done_; + mutable bool current_loop_; // Current arc is the implicit loop. + mutable bool final_arc_; // Current arc for exiting recursion. + mutable StateTuple tuple_; // Tuple corresponding to state_. + mutable Arc arc_; + Arc loop_; + + ReplaceFstMatcher &operator=(const ReplaceFstMatcher &) = delete; +}; + +template +inline void ReplaceFst::InitStateIterator( + StateIteratorData *data) const { + data->base = + new StateIterator>(*this); +} + +using StdReplaceFst = ReplaceFst; + +// Recursively replaces arcs in the root FSTs with other FSTs. +// This version writes the result of replacement to an output MutableFst. +// +// Replace supports replacement of arcs in one Fst with another FST. This +// replacement is recursive. Replace takes an array of FST(s). One FST +// represents the root (or topology) machine. The root FST refers to other FSTs +// by recursively replacing arcs labeled as non-terminals with the matching +// non-terminal FST. Currently Replace uses the output symbols of the arcs to +// determine whether the arc is a non-terminal arc or not. A non-terminal can be +// any label that is not a non-zero terminal label in the output alphabet. +// +// Note that input argument is a vector of pairs. These correspond to the tuple +// of non-terminal Label and corresponding FST. +template +void Replace(const std::vector *>> + &ifst_array, + MutableFst *ofst, + ReplaceFstOptions opts = ReplaceFstOptions()) { + opts.gc = true; + opts.gc_limit = 0; // Caches only the last state for fastest copy. + *ofst = ReplaceFst(ifst_array, opts); +} + +template +void Replace(const std::vector *>> + &ifst_array, + MutableFst *ofst, const ReplaceUtilOptions &opts) { + Replace(ifst_array, ofst, ReplaceFstOptions(opts)); +} + +// For backwards compatibility. +template +void Replace(const std::vector *>> + &ifst_array, + MutableFst *ofst, typename Arc::Label root, + bool epsilon_on_replace) { + Replace(ifst_array, ofst, ReplaceFstOptions(root, epsilon_on_replace)); +} + +template +void Replace(const std::vector *>> + &ifst_array, + MutableFst *ofst, typename Arc::Label root) { + Replace(ifst_array, ofst, ReplaceFstOptions(root)); +} + +} // namespace fst + +#endif // FST_REPLACE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/reverse.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/reverse.h new file mode 100644 index 0000000000..7c7c89dbd0 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/reverse.h @@ -0,0 +1,116 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Functions and classes to sort arcs in an FST. + +#ifndef FST_REVERSE_H_ +#define FST_REVERSE_H_ + +#include +#include + +#include + + +namespace fst { + +// Reverses an FST. The reversed result is written to an output mutable FST. +// If A transduces string x to y with weight a, then the reverse of A +// transduces the reverse of x to the reverse of y with weight a.Reverse(). +// +// Typically, a = a.Reverse() and an arc is its own reverse (e.g., for +// TropicalWeight or LogWeight). In general, e.g., when the weights only form a +// left or right semiring, the output arc type must match the input arc type +// except having the reversed Weight type. +// +// When require_superinitial is false, a superinitial state is not created in +// the reversed FST iff the input FST has exactly one final state (which becomes +// the initial state of the reversed FST) with a final weight of semiring One, +// or if it does not belong to any cycle. When require_superinitial is true, a +// superinitial state is always created. +template +void Reverse(const Fst &ifst, MutableFst *ofst, + bool require_superinitial = true) { + using StateId = typename FromArc::StateId; + using FromWeight = typename FromArc::Weight; + using ToWeight = typename ToArc::Weight; + ofst->DeleteStates(); + ofst->SetInputSymbols(ifst.InputSymbols()); + ofst->SetOutputSymbols(ifst.OutputSymbols()); + if (ifst.Properties(kExpanded, false)) { + ofst->ReserveStates(CountStates(ifst) + 1); + } + StateId istart = ifst.Start(); + StateId ostart = kNoStateId; + StateId offset = 0; + uint64 dfs_iprops = 0; + uint64 dfs_oprops = 0; + if (!require_superinitial) { + for (StateIterator> siter(ifst); !siter.Done(); siter.Next()) { + const auto s = siter.Value(); + if (ifst.Final(s) == FromWeight::Zero()) continue; + if (ostart != kNoStateId) { + ostart = kNoStateId; + break; + } else { + ostart = s; + } + } + if (ostart != kNoStateId && ifst.Final(ostart) != FromWeight::One()) { + std::vector scc; + SccVisitor scc_visitor(&scc, nullptr, nullptr, &dfs_iprops); + DfsVisit(ifst, &scc_visitor); + if (count(scc.begin(), scc.end(), scc[ostart]) > 1) { + ostart = kNoStateId; + } else { + for (ArcIterator> aiter(ifst, ostart); !aiter.Done(); + aiter.Next()) { + if (aiter.Value().nextstate == ostart) { + ostart = kNoStateId; + break; + } + } + } + if (ostart != kNoStateId) dfs_oprops = kInitialAcyclic; + } + } + if (ostart == kNoStateId) { // Super-initial requested or needed. + ostart = ofst->AddState(); + offset = 1; + } + for (StateIterator> siter(ifst); !siter.Done(); siter.Next()) { + const auto is = siter.Value(); + const auto os = is + offset; + while (ofst->NumStates() <= os) ofst->AddState(); + if (is == istart) ofst->SetFinal(os, ToWeight::One()); + const auto weight = ifst.Final(is); + if ((weight != FromWeight::Zero()) && (offset == 1)) { + const ToArc oarc(0, 0, weight.Reverse(), os); + ofst->AddArc(0, oarc); + } + for (ArcIterator> aiter(ifst, is); !aiter.Done(); + aiter.Next()) { + const auto &iarc = aiter.Value(); + const auto nos = iarc.nextstate + offset; + auto weight = iarc.weight.Reverse(); + if (!offset && (nos == ostart)) { + weight = Times(ifst.Final(ostart).Reverse(), weight); + } + const ToArc oarc(iarc.ilabel, iarc.olabel, weight, os); + while (ofst->NumStates() <= nos) ofst->AddState(); + ofst->AddArc(nos, oarc); + } + } + ofst->SetStart(ostart); + if (offset == 0 && ostart == istart) { + ofst->SetFinal(ostart, ifst.Final(ostart).Reverse()); + } + const auto iprops = ifst.Properties(kCopyProperties, false) | dfs_iprops; + const auto oprops = ofst->Properties(kFstProperties, false) | dfs_oprops; + ofst->SetProperties(ReverseProperties(iprops, offset == 1) | oprops, + kFstProperties); +} + +} // namespace fst + +#endif // FST_REVERSE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/reweight.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/reweight.h new file mode 100644 index 0000000000..64e68cb7aa --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/reweight.h @@ -0,0 +1,127 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Function to reweight an FST. + +#ifndef FST_REWEIGHT_H_ +#define FST_REWEIGHT_H_ + +#include +#include + +#include + + +namespace fst { + +enum ReweightType { REWEIGHT_TO_INITIAL, REWEIGHT_TO_FINAL }; + +// Reweights an FST according to a vector of potentials in a given direction. +// The weight must be left distributive when reweighting towards the initial +// state and right distributive when reweighting towards the final states. +// +// An arc of weight w, with an origin state of potential p and destination state +// of potential q, is reweighted by p^-1 \otimes (w \otimes q) when reweighting +// torwards the initial state, and by (p \otimes w) \otimes q^-1 when +// reweighting towards the final states. +template +void Reweight(MutableFst *fst, + const std::vector &potential, + ReweightType type) { + using Weight = typename Arc::Weight; + if (fst->NumStates() == 0) return; + // TODO(kbg): Make this a compile-time static_assert once we have a pleasant + // way to "deregister" this operation for non-distributive semirings so an + // informative error message is produced. + if (type == REWEIGHT_TO_FINAL && !(Weight::Properties() & kRightSemiring)) { + FSTERROR() << "Reweight: Reweighting to the final states requires " + << "Weight to be right distributive: " << Weight::Type(); + fst->SetProperties(kError, kError); + return; + } + // TODO(kbg): Make this a compile-time static_assert once we have a pleasant + // way to "deregister" this operation for non-distributive semirings so an + // informative error message is produced. + if (type == REWEIGHT_TO_INITIAL && !(Weight::Properties() & kLeftSemiring)) { + FSTERROR() << "Reweight: Reweighting to the initial state requires " + << "Weight to be left distributive: " << Weight::Type(); + fst->SetProperties(kError, kError); + return; + } + StateIterator> siter(*fst); + for (; !siter.Done(); siter.Next()) { + const auto s = siter.Value(); + if (s == potential.size()) break; + const auto &weight = potential[s]; + if (weight != Weight::Zero()) { + for (MutableArcIterator> aiter(fst, s); !aiter.Done(); + aiter.Next()) { + auto arc = aiter.Value(); + if (arc.nextstate >= potential.size()) continue; + const auto &nextweight = potential[arc.nextstate]; + if (nextweight == Weight::Zero()) continue; + if (type == REWEIGHT_TO_INITIAL) { + arc.weight = + Divide(Times(arc.weight, nextweight), weight, DIVIDE_LEFT); + } + if (type == REWEIGHT_TO_FINAL) { + arc.weight = + Divide(Times(weight, arc.weight), nextweight, DIVIDE_RIGHT); + } + aiter.SetValue(arc); + } + if (type == REWEIGHT_TO_INITIAL) { + fst->SetFinal(s, Divide(fst->Final(s), weight, DIVIDE_LEFT)); + } + } + if (type == REWEIGHT_TO_FINAL) { + fst->SetFinal(s, Times(weight, fst->Final(s))); + } + } + // This handles elements past the end of the potentials array. + for (; !siter.Done(); siter.Next()) { + const auto s = siter.Value(); + if (type == REWEIGHT_TO_FINAL) { + fst->SetFinal(s, Times(Weight::Zero(), fst->Final(s))); + } + } + const auto startweight = fst->Start() < potential.size() + ? potential[fst->Start()] + : Weight::Zero(); + if ((startweight != Weight::One()) && (startweight != Weight::Zero())) { + if (fst->Properties(kInitialAcyclic, true) & kInitialAcyclic) { + const auto s = fst->Start(); + for (MutableArcIterator> aiter(fst, s); !aiter.Done(); + aiter.Next()) { + auto arc = aiter.Value(); + if (type == REWEIGHT_TO_INITIAL) { + arc.weight = Times(startweight, arc.weight); + } else { + arc.weight = Times(Divide(Weight::One(), startweight, DIVIDE_RIGHT), + arc.weight); + } + aiter.SetValue(arc); + } + if (type == REWEIGHT_TO_INITIAL) { + fst->SetFinal(s, Times(startweight, fst->Final(s))); + } else { + fst->SetFinal(s, Times(Divide(Weight::One(), startweight, DIVIDE_RIGHT), + fst->Final(s))); + } + } else { + const auto s = fst->AddState(); + const auto weight = + (type == REWEIGHT_TO_INITIAL) + ? startweight + : Divide(Weight::One(), startweight, DIVIDE_RIGHT); + fst->AddArc(s, Arc(0, 0, weight, fst->Start())); + fst->SetStart(s); + } + } + fst->SetProperties(ReweightProperties(fst->Properties(kFstProperties, false)), + kFstProperties); +} + +} // namespace fst + +#endif // FST_REWEIGHT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/rmepsilon.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/rmepsilon.h new file mode 100644 index 0000000000..4606101167 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/rmepsilon.h @@ -0,0 +1,549 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Functions and classes that implemement epsilon-removal. + +#ifndef FST_RMEPSILON_H_ +#define FST_RMEPSILON_H_ + +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace fst { + +template +class RmEpsilonOptions + : public ShortestDistanceOptions> { + public: + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + bool connect; // Connect output + Weight weight_threshold; // Pruning weight threshold. + StateId state_threshold; // Pruning state threshold. + + explicit RmEpsilonOptions(Queue *queue, float delta = kShortestDelta, + bool connect = true, + Weight weight_threshold = Weight::Zero(), + StateId state_threshold = kNoStateId) + : ShortestDistanceOptions>( + queue, EpsilonArcFilter(), kNoStateId, delta), + connect(connect), + weight_threshold(std::move(weight_threshold)), + state_threshold(state_threshold) {} +}; + +namespace internal { + +// Computation state of the epsilon-removal algorithm. +template +class RmEpsilonState { + public: + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + RmEpsilonState(const Fst &fst, std::vector *distance, + const RmEpsilonOptions &opts) + : fst_(fst), + distance_(distance), + sd_state_(fst_, distance, opts, true), + expand_id_(0) {} + + void Expand(StateId s); + + std::vector &Arcs() { return arcs_; } + + const Weight &Final() const { return final_; } + + bool Error() const { return sd_state_.Error(); } + + private: + struct Element { + Label ilabel; + Label olabel; + StateId nextstate; + + Element() {} + + Element(Label ilabel, Label olabel, StateId nexstate) + : ilabel(ilabel), olabel(olabel), nextstate(nexstate) {} + }; + + struct ElementHash { + public: + size_t operator()(const Element &element) const { + static constexpr size_t prime0 = 7853; + static constexpr size_t prime1 = 7867; + return static_cast(element.nextstate) + + static_cast(element.ilabel) * prime0 + + static_cast(element.olabel) * prime1; + } + }; + + class ElementEqual { + public: + bool operator()(const Element &e1, const Element &e2) const { + return (e1.ilabel == e2.ilabel) && (e1.olabel == e2.olabel) && + (e1.nextstate == e2.nextstate); + } + }; + + using ElementMap = std::unordered_map, + ElementHash, ElementEqual>; + + const Fst &fst_; + // Distance from state being expanded in epsilon-closure. + std::vector *distance_; + // Shortest distance algorithm computation state. + internal::ShortestDistanceState> sd_state_; + // Maps an element to a pair corresponding to a position in the arcs vector + // of the state being expanded. The element corresopnds to the position in + // the arcs_ vector if p.first is equal to the state being expanded. + ElementMap element_map_; + EpsilonArcFilter eps_filter_; + std::stack eps_queue_; // Queue used to visit the epsilon-closure. + std::vector visited_; // True if the state has been visited. + std::forward_list visited_states_; // List of visited states. + std::vector arcs_; // Arcs of state being expanded. + Weight final_; // Final weight of state being expanded. + StateId expand_id_; // Unique ID for each call to Expand + + RmEpsilonState(const RmEpsilonState &) = delete; + RmEpsilonState &operator=(const RmEpsilonState &) = delete; +}; + +template +void RmEpsilonState::Expand(typename Arc::StateId source) { + final_ = Weight::Zero(); + arcs_.clear(); + sd_state_.ShortestDistance(source); + if (sd_state_.Error()) return; + eps_queue_.push(source); + while (!eps_queue_.empty()) { + const auto state = eps_queue_.top(); + eps_queue_.pop(); + while (visited_.size() <= state) visited_.push_back(false); + if (visited_[state]) continue; + visited_[state] = true; + visited_states_.push_front(state); + for (ArcIterator> aiter(fst_, state); !aiter.Done(); + aiter.Next()) { + auto arc = aiter.Value(); + arc.weight = Times((*distance_)[state], arc.weight); + if (eps_filter_(arc)) { + while (visited_.size() <= arc.nextstate) visited_.push_back(false); + if (!visited_[arc.nextstate]) eps_queue_.push(arc.nextstate); + } else { + const Element element(arc.ilabel, arc.olabel, arc.nextstate); + auto insert_result = element_map_.insert( + std::make_pair(element, std::make_pair(expand_id_, arcs_.size()))); + if (insert_result.second) { + arcs_.push_back(arc); + } else { + if (insert_result.first->second.first == expand_id_) { + auto &weight = arcs_[insert_result.first->second.second].weight; + weight = Plus(weight, arc.weight); + } else { + insert_result.first->second.first = expand_id_; + insert_result.first->second.second = arcs_.size(); + arcs_.push_back(arc); + } + } + } + } + final_ = Plus(final_, Times((*distance_)[state], fst_.Final(state))); + } + while (!visited_states_.empty()) { + visited_[visited_states_.front()] = false; + visited_states_.pop_front(); + } + ++expand_id_; +} + +} // namespace internal + +// Removes epsilon-transitions (when both the input and output label are an +// epsilon) from a transducer. The result will be an equivalent FST that has no +// such epsilon transitions. This version modifies its input. It allows fine +// control via the options argument; see below for a simpler interface. +// +// The distance vector will be used to hold the shortest distances during the +// epsilon-closure computation. The state queue discipline and convergence delta +// are taken in the options argument. +template +void RmEpsilon(MutableFst *fst, + std::vector *distance, + const RmEpsilonOptions &opts) { + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + if (fst->Start() == kNoStateId) return; + // noneps_in[s] will be set to true iff s admits a non-epsilon incoming + // transition or is the start state. + std::vector noneps_in(fst->NumStates(), false); + noneps_in[fst->Start()] = true; + for (size_t i = 0; i < fst->NumStates(); ++i) { + for (ArcIterator> aiter(*fst, i); !aiter.Done(); aiter.Next()) { + const auto &arc = aiter.Value(); + if (arc.ilabel != 0 || arc.olabel != 0) { + noneps_in[arc.nextstate] = true; + } + } + } + // States sorted in topological order when (acyclic) or generic topological + // order (cyclic). + std::vector states; + states.reserve(fst->NumStates()); + if (fst->Properties(kTopSorted, false) & kTopSorted) { + for (size_t i = 0; i < fst->NumStates(); i++) states.push_back(i); + } else if (fst->Properties(kAcyclic, false) & kAcyclic) { + std::vector order; + bool acyclic; + TopOrderVisitor top_order_visitor(&order, &acyclic); + DfsVisit(*fst, &top_order_visitor, EpsilonArcFilter()); + // Sanity check: should be acyclic if property bit is set. + if (!acyclic) { + FSTERROR() << "RmEpsilon: Inconsistent acyclic property bit"; + fst->SetProperties(kError, kError); + return; + } + states.resize(order.size()); + for (StateId i = 0; i < order.size(); i++) states[order[i]] = i; + } else { + uint64 props; + std::vector scc; + SccVisitor scc_visitor(&scc, nullptr, nullptr, &props); + DfsVisit(*fst, &scc_visitor, EpsilonArcFilter()); + std::vector first(scc.size(), kNoStateId); + std::vector next(scc.size(), kNoStateId); + for (StateId i = 0; i < scc.size(); i++) { + if (first[scc[i]] != kNoStateId) next[i] = first[scc[i]]; + first[scc[i]] = i; + } + for (StateId i = 0; i < first.size(); i++) { + for (auto j = first[i]; j != kNoStateId; j = next[j]) { + states.push_back(j); + } + } + } + internal::RmEpsilonState rmeps_state(*fst, distance, opts); + while (!states.empty()) { + const auto state = states.back(); + states.pop_back(); + if (!noneps_in[state] && + (opts.connect || opts.weight_threshold != Weight::Zero() || + opts.state_threshold != kNoStateId)) { + continue; + } + rmeps_state.Expand(state); + fst->SetFinal(state, rmeps_state.Final()); + fst->DeleteArcs(state); + auto &arcs = rmeps_state.Arcs(); + fst->ReserveArcs(state, arcs.size()); + while (!arcs.empty()) { + fst->AddArc(state, arcs.back()); + arcs.pop_back(); + } + } + if (opts.connect || opts.weight_threshold != Weight::Zero() || + opts.state_threshold != kNoStateId) { + for (size_t s = 0; s < fst->NumStates(); ++s) { + if (!noneps_in[s]) fst->DeleteArcs(s); + } + } + if (rmeps_state.Error()) fst->SetProperties(kError, kError); + fst->SetProperties( + RmEpsilonProperties(fst->Properties(kFstProperties, false)), + kFstProperties); + if (opts.weight_threshold != Weight::Zero() || + opts.state_threshold != kNoStateId) { + Prune(fst, opts.weight_threshold, opts.state_threshold); + } + if (opts.connect && opts.weight_threshold == Weight::Zero() && + opts.state_threshold == kNoStateId) { + Connect(fst); + } +} + +// Removes epsilon-transitions (when both the input and output label +// are an epsilon) from a transducer. The result will be an equivalent +// FST that has no such epsilon transitions. This version modifies its +// input. It has a simplified interface; see above for a version that +// allows finer control. +// +// Complexity: +// +// - Time: +// +// Unweighted: O(v^2 + ve). +// Acyclic: O(v^2 + V e). +// Tropical semiring: O(v^2 log V + ve). +// General: exponential. +// +// - Space: O(vE) +// +// where v is the number of states visited and e is the number of arcs visited. +// +// For more information, see: +// +// Mohri, M. 2002. Generic epsilon-removal and input epsilon-normalization +// algorithms for weighted transducers. International Journal of Computer +// Science 13(1): 129-143. +template +void RmEpsilon(MutableFst *fst, bool connect = true, + typename Arc::Weight weight_threshold = Arc::Weight::Zero(), + typename Arc::StateId state_threshold = kNoStateId, + float delta = kShortestDelta) { + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + std::vector distance; + AutoQueue state_queue(*fst, &distance, EpsilonArcFilter()); + RmEpsilonOptions> opts( + &state_queue, delta, connect, weight_threshold, state_threshold); + RmEpsilon(fst, &distance, opts); +} + +struct RmEpsilonFstOptions : CacheOptions { + float delta; + + explicit RmEpsilonFstOptions(const CacheOptions &opts, + float delta = kShortestDelta) + : CacheOptions(opts), delta(delta) {} + + explicit RmEpsilonFstOptions(float delta = kShortestDelta) : delta(delta) {} +}; + +namespace internal { + +// Implementation of delayed RmEpsilonFst. +template +class RmEpsilonFstImpl : public CacheImpl { + public: + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using Store = DefaultCacheStore; + using State = typename Store::State; + + using FstImpl::Properties; + using FstImpl::SetType; + using FstImpl::SetProperties; + using FstImpl::SetInputSymbols; + using FstImpl::SetOutputSymbols; + + using CacheBaseImpl>::HasArcs; + using CacheBaseImpl>::HasFinal; + using CacheBaseImpl>::HasStart; + using CacheBaseImpl>::PushArc; + using CacheBaseImpl>::SetArcs; + using CacheBaseImpl>::SetFinal; + using CacheBaseImpl>::SetStart; + + RmEpsilonFstImpl(const Fst &fst, const RmEpsilonFstOptions &opts) + : CacheImpl(opts), + fst_(fst.Copy()), + delta_(opts.delta), + rmeps_state_( + *fst_, &distance_, + RmEpsilonOptions>(&queue_, delta_, false)) { + SetType("rmepsilon"); + SetProperties( + RmEpsilonProperties(fst.Properties(kFstProperties, false), true), + kCopyProperties); + SetInputSymbols(fst.InputSymbols()); + SetOutputSymbols(fst.OutputSymbols()); + } + + RmEpsilonFstImpl(const RmEpsilonFstImpl &impl) + : CacheImpl(impl), + fst_(impl.fst_->Copy(true)), + delta_(impl.delta_), + rmeps_state_( + *fst_, &distance_, + RmEpsilonOptions>(&queue_, delta_, false)) { + SetType("rmepsilon"); + SetProperties(impl.Properties(), kCopyProperties); + SetInputSymbols(impl.InputSymbols()); + SetOutputSymbols(impl.OutputSymbols()); + } + + StateId Start() { + if (!HasStart()) SetStart(fst_->Start()); + return CacheImpl::Start(); + } + + Weight Final(StateId s) { + if (!HasFinal(s)) Expand(s); + return CacheImpl::Final(s); + } + + size_t NumArcs(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumArcs(s); + } + + size_t NumInputEpsilons(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumInputEpsilons(s); + } + + size_t NumOutputEpsilons(StateId s) { + if (!HasArcs(s)) Expand(s); + return CacheImpl::NumOutputEpsilons(s); + } + + uint64 Properties() const override { return Properties(kFstProperties); } + + // Sets error if found and returns other FST impl properties. + uint64 Properties(uint64 mask) const override { + if ((mask & kError) && + (fst_->Properties(kError, false) || rmeps_state_.Error())) { + SetProperties(kError, kError); + } + return FstImpl::Properties(mask); + } + + void InitArcIterator(StateId s, ArcIteratorData *data) { + if (!HasArcs(s)) Expand(s); + CacheImpl::InitArcIterator(s, data); + } + + void Expand(StateId s) { + rmeps_state_.Expand(s); + SetFinal(s, rmeps_state_.Final()); + auto &arcs = rmeps_state_.Arcs(); + while (!arcs.empty()) { + PushArc(s, arcs.back()); + arcs.pop_back(); + } + SetArcs(s); + } + + private: + std::unique_ptr> fst_; + float delta_; + std::vector distance_; + FifoQueue queue_; + internal::RmEpsilonState> rmeps_state_; +}; + +} // namespace internal + +// Removes epsilon-transitions (when both the input and output label are an +// epsilon) from a transducer. The result will be an equivalent FST that has no +// such epsilon transitions. This version is a +// delayed FST. +// +// Complexity: +// +// - Time: +// Unweighted: O(v^2 + ve). +// General: exponential. +// +// - Space: O(vE) +// +// where v is the number of states visited and e is the number of arcs visited. +// Constant time to visit an input state or arc is assumed and exclusive of +// caching. +// +// For more information, see: +// +// Mohri, M. 2002. Generic epsilon-removal and input epsilon-normalization +// algorithms for weighted transducers. International Journal of Computer +// Science 13(1): 129-143. +// +// This class attaches interface to implementation and handles +// reference counting, delegating most methods to ImplToFst. +template +class RmEpsilonFst : public ImplToFst> { + public: + using Arc = A; + using StateId = typename Arc::StateId; + + using Store = DefaultCacheStore; + using State = typename Store::State; + using Impl = internal::RmEpsilonFstImpl; + + friend class ArcIterator>; + friend class StateIterator>; + + explicit RmEpsilonFst(const Fst &fst) + : ImplToFst(std::make_shared(fst, RmEpsilonFstOptions())) {} + + RmEpsilonFst(const Fst &fst, const RmEpsilonFstOptions &opts) + : ImplToFst(std::make_shared(fst, opts)) {} + + // See Fst<>::Copy() for doc. + RmEpsilonFst(const RmEpsilonFst &fst, bool safe = false) + : ImplToFst(fst, safe) {} + + // Get a copy of this RmEpsilonFst. See Fst<>::Copy() for further doc. + RmEpsilonFst *Copy(bool safe = false) const override { + return new RmEpsilonFst(*this, safe); + } + + inline void InitStateIterator(StateIteratorData *data) const override; + + void InitArcIterator(StateId s, ArcIteratorData *data) const override { + GetMutableImpl()->InitArcIterator(s, data); + } + + private: + using ImplToFst::GetImpl; + using ImplToFst::GetMutableImpl; + + RmEpsilonFst &operator=(const RmEpsilonFst &) = delete; +}; + +// Specialization for RmEpsilonFst. +template +class StateIterator> + : public CacheStateIterator> { + public: + explicit StateIterator(const RmEpsilonFst &fst) + : CacheStateIterator>(fst, fst.GetMutableImpl()) {} +}; + +// Specialization for RmEpsilonFst. +template +class ArcIterator> + : public CacheArcIterator> { + public: + using StateId = typename Arc::StateId; + + ArcIterator(const RmEpsilonFst &fst, StateId s) + : CacheArcIterator>(fst.GetMutableImpl(), s) { + if (!fst.GetImpl()->HasArcs(s)) fst.GetMutableImpl()->Expand(s); + } +}; + +template +inline void RmEpsilonFst::InitStateIterator( + StateIteratorData *data) const { + data->base = new StateIterator>(*this); +} + +// Useful alias when using StdArc. +using StdRmEpsilonFst = RmEpsilonFst; + +} // namespace fst + +#endif // FST_RMEPSILON_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/rmfinalepsilon.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/rmfinalepsilon.h new file mode 100644 index 0000000000..87e3a7147e --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/rmfinalepsilon.h @@ -0,0 +1,80 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Function to remove of final states that have epsilon-only input arcs. + +#ifndef FST_RMFINALEPSILON_H_ +#define FST_RMFINALEPSILON_H_ + +#include +#include + +#include +#include + + +namespace fst { + +// Removes final states that have epsilon-only input arcs. +template +void RmFinalEpsilon(MutableFst *fst) { + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + // Determines the coaccesibility of states. + std::vector access; + std::vector coaccess; + uint64 props = 0; + SccVisitor scc_visitor(nullptr, &access, &coaccess, &props); + DfsVisit(*fst, &scc_visitor); + // Finds potential list of removable final states. These are final states that + // have no outgoing transitions or final states that have a non-coaccessible + // future. + std::unordered_set finals; + for (StateIterator> siter(*fst); !siter.Done(); siter.Next()) { + const auto s = siter.Value(); + if (fst->Final(s) != Weight::Zero()) { + bool future_coaccess = false; + for (ArcIterator> aiter(*fst, s); !aiter.Done(); aiter.Next()) { + const auto &arc = aiter.Value(); + if (coaccess[arc.nextstate]) { + future_coaccess = true; + break; + } + } + if (!future_coaccess) finals.insert(s); + } + } + // Moves the final weight. + std::vector arcs; + for (StateIterator> siter(*fst); !siter.Done(); siter.Next()) { + const auto s = siter.Value(); + auto weight = fst->Final(s); + arcs.clear(); + for (ArcIterator> aiter(*fst, s); !aiter.Done(); aiter.Next()) { + const auto &arc = aiter.Value(); + // Next state is in the list of finals. + if (finals.find(arc.nextstate) != finals.end()) { + // Sums up all epsilon arcs. + if (arc.ilabel == 0 && arc.olabel == 0) { + weight = Plus(Times(fst->Final(arc.nextstate), arc.weight), weight); + } else { + arcs.push_back(arc); + } + } else { + arcs.push_back(arc); + } + } + // If some arcs (epsilon arcs) were deleted, delete all arcs and add back + // only the non-epsilon arcs. + if (arcs.size() < fst->NumArcs(s)) { + fst->DeleteArcs(s); + fst->SetFinal(s, weight); + for (const auto &arc : arcs) fst->AddArc(s, arc); + } + } + Connect(fst); +} + +} // namespace fst + +#endif // FST_RMFINALEPSILON_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/arc-class.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/arc-class.h new file mode 100644 index 0000000000..551266d7cf --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/arc-class.h @@ -0,0 +1,40 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_ARC_CLASS_H_ +#define FST_SCRIPT_ARC_CLASS_H_ + +#include + +namespace fst { +namespace script { + +// A struct representing an arc while ignoring arc type. It is passed as an +// argument to AddArc. + +struct ArcClass { + template + explicit ArcClass(const Arc &arc) + : ilabel(arc.ilabel), olabel(arc.olabel), weight(arc.weight), + nextstate(arc.nextstate) {} + + ArcClass(int64 ilabel, int64 olabel, const WeightClass &weight, + int64 nextstate) + : ilabel(ilabel), olabel(olabel), weight(weight), nextstate(nextstate) {} + + template + Arc GetArc() const { + return Arc(ilabel, olabel, *(weight.GetWeight()), + nextstate); + } + + int64 ilabel; + int64 olabel; + WeightClass weight; + int64 nextstate; +}; + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_ARC_CLASS_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/arciterator-class.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/arciterator-class.h new file mode 100644 index 0000000000..8e4ca4f831 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/arciterator-class.h @@ -0,0 +1,212 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_ARCITERATOR_CLASS_H_ +#define FST_SCRIPT_ARCITERATOR_CLASS_H_ + +#include +#include + +#include +#include + +// Scripting API support for ArcIterator. +// +// A call to Value() causes the underlying arc to be used to construct the +// associated ArcClass. + +namespace fst { +namespace script { + +// Non-mutable arc iterators. + +// Virtual interface implemented by each concrete ArcIteratorImpl. +class ArcIteratorImplBase { + public: + virtual bool Done() const = 0; + virtual uint32 Flags() const = 0; + virtual void Next() = 0; + virtual size_t Position() const = 0; + virtual void Reset() = 0; + virtual void Seek(size_t a) = 0; + virtual void SetFlags(uint32 flags, uint32 mask) = 0; + virtual ArcClass Value() const = 0; + virtual ~ArcIteratorImplBase() {} +}; + +// Templated implementation. +template +class ArcIteratorClassImpl : public ArcIteratorImplBase { + public: + explicit ArcIteratorClassImpl(const Fst &fst, int64 s) + : aiter_(fst, s) {} + + bool Done() const final { return aiter_.Done(); } + + uint32 Flags() const final { return aiter_.Flags(); } + + void Next() final { aiter_.Next(); } + + size_t Position() const final { return aiter_.Position(); } + + void Reset() final { aiter_.Reset(); } + + void Seek(size_t a) final { aiter_.Seek(a); } + + void SetFlags(uint32 flags, uint32 mask) final { + aiter_.SetFlags(flags, mask); + } + + // This is returned by value because it has not yet been constructed, and + // is likely to participate in return-value optimization. + ArcClass Value() const final { return ArcClass(aiter_.Value()); } + + ~ArcIteratorClassImpl() final {} + + private: + ArcIterator> aiter_; +}; + +class ArcIteratorClass; + +using InitArcIteratorClassArgs = + std::tuple; + +// Untemplated user-facing class holding a templated pimpl. +class ArcIteratorClass { + public: + ArcIteratorClass(const FstClass &fst, int64 s); + + template + ArcIteratorClass(const Fst &fst, int64 s) + : impl_(new ArcIteratorClassImpl(fst, s)) {} + + bool Done() const { return impl_->Done(); } + + uint32 Flags() const { return impl_->Flags(); } + + void Next() { impl_->Next(); } + + size_t Position() const { return impl_->Position(); } + + void Reset() { impl_->Reset(); } + + void Seek(size_t a) { impl_->Seek(a); } + + void SetFlags(uint32 flags, uint32 mask) { impl_->SetFlags(flags, mask); } + + ArcClass Value() const { return impl_->Value(); } + + template + friend void InitArcIteratorClass(InitArcIteratorClassArgs *args); + + private: + std::unique_ptr impl_; +}; + +template +void InitArcIteratorClass(InitArcIteratorClassArgs *args) { + const Fst &fst = *(std::get<0>(*args).GetFst()); + std::get<2>(*args)->impl_.reset( + new ArcIteratorClassImpl(fst, std::get<1>(*args))); +} + +// Mutable arc iterators. + +// Virtual interface implemented by each concrete MutableArcIteratorImpl. +class MutableArcIteratorImplBase : public ArcIteratorImplBase { + public: + virtual void SetValue(const ArcClass &) = 0; + + ~MutableArcIteratorImplBase() override {} +}; + +// Templated implementation. +template +class MutableArcIteratorClassImpl + : public MutableArcIteratorImplBase { + public: + explicit MutableArcIteratorClassImpl(MutableFst *fst, int64 s) + : aiter_(fst, s) {} + + bool Done() const final { return aiter_.Done(); } + + uint32 Flags() const final { return aiter_.Flags(); } + + void Next() final { aiter_.Next(); } + + size_t Position() const final { return aiter_.Position(); } + + void Reset() final { aiter_.Reset(); } + + void Seek(size_t a) final { aiter_.Seek(a); } + + void SetFlags(uint32 flags, uint32 mask) final { + aiter_.SetFlags(flags, mask); + } + + void SetValue(const Arc &arc) { aiter_.SetValue(arc); } + + void SetValue(const ArcClass &ac) final { aiter_.SetValue(ac.GetArc()); } + + // This is returned by value because it has not yet been constructed, and + // is likely to participate in return-value optimization. + ArcClass Value() const final { return ArcClass(aiter_.Value()); } + + ~MutableArcIteratorClassImpl() override {} + + private: + MutableArcIterator> aiter_; +}; + +class MutableArcIteratorClass; + +using InitMutableArcIteratorClassArgs = + std::tuple; + +// Untemplated user-facing class holding a templated pimpl. +class MutableArcIteratorClass { + public: + MutableArcIteratorClass(MutableFstClass *fst, int64 s); + + template + MutableArcIteratorClass(MutableFst *fst, int64 s) + : impl_(new MutableArcIteratorClassImpl(fst, s)) {} + + bool Done() const { return impl_->Done(); } + + uint32 Flags() const { return impl_->Flags(); } + + void Next() { impl_->Next(); } + + size_t Position() const { return impl_->Position(); } + + void Reset() { impl_->Reset(); } + + void Seek(size_t a) { impl_->Seek(a); } + + void SetFlags(uint32 flags, uint32 mask) { impl_->SetFlags(flags, mask); } + + void SetValue(const ArcClass &ac) { impl_->SetValue(ac); } + + ArcClass Value() const { return impl_->Value(); } + + template + friend void InitMutableArcIteratorClass( + InitMutableArcIteratorClassArgs *args); + + private: + std::unique_ptr impl_; +}; + +template +void InitMutableArcIteratorClass(InitMutableArcIteratorClassArgs *args) { + MutableFst *fst = std::get<0>(*args)->GetMutableFst(); + std::get<2>(*args)->impl_.reset( + new MutableArcIteratorClassImpl(fst, std::get<1>(*args))); +} + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_ARCITERATOR_CLASS_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/arcsort.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/arcsort.h new file mode 100644 index 0000000000..3e56fe5c4a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/arcsort.h @@ -0,0 +1,44 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_ARCSORT_H_ +#define FST_SCRIPT_ARCSORT_H_ + +#include + +#include +#include + +namespace fst { +namespace script { + +enum ArcSortType { + ILABEL_SORT, + OLABEL_SORT +}; + +using ArcSortArgs = std::pair; + +template +void ArcSort(ArcSortArgs *args) { + MutableFst *fst = std::get<0>(*args)->GetMutableFst(); + switch (std::get<1>(*args)) { + case ILABEL_SORT: { + const ILabelCompare icomp; + ArcSort(fst, icomp); + return; + } + case OLABEL_SORT: { + const OLabelCompare ocomp; + ArcSort(fst, ocomp); + return; + } + } +} + +void ArcSort(MutableFstClass *ofst, ArcSortType); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_ARCSORT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/arg-packs.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/arg-packs.h new file mode 100644 index 0000000000..93cd4a052e --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/arg-packs.h @@ -0,0 +1,37 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// std::pair and std::tuple are used for the arguments of FstClass operations. +// +// If a function with a return value is required, use the WithReturnValue +// template as follows: +// +// WithReturnValue> + +#ifndef FST_SCRIPT_ARG_PACKS_H_ +#define FST_SCRIPT_ARG_PACKS_H_ + +#include + +namespace fst { +namespace script { + +// Tack this on to an existing type to add a return value. The syntax for +// accessing the args is then slightly more stilted, as you must do an extra +// member access (since the args are stored as a member of this class). + +template +struct WithReturnValue { + // Avoid reference-to-reference if ArgTuple is a reference. + using Args = typename std::remove_reference::type; + + Retval retval; + const Args &args; + + explicit WithReturnValue(const Args &args) : args(args) {} +}; + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_ARG_PACKS_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/closure.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/closure.h new file mode 100644 index 0000000000..7c68604abc --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/closure.h @@ -0,0 +1,28 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_CLOSURE_H_ +#define FST_SCRIPT_CLOSURE_H_ + +#include + +#include +#include + +namespace fst { +namespace script { + +using ClosureArgs = std::pair; + +template +void Closure(ClosureArgs *args) { + MutableFst *fst = std::get<0>(*args)->GetMutableFst(); + Closure(fst, std::get<1>(*args)); +} + +void Closure(MutableFstClass *ofst, ClosureType closure_type); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_CLOSURE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/compile-impl.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/compile-impl.h new file mode 100644 index 0000000000..943a0b721b --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/compile-impl.h @@ -0,0 +1,217 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Class to to compile a binary FST from textual input. + +#ifndef FST_SCRIPT_COMPILE_IMPL_H_ +#define FST_SCRIPT_COMPILE_IMPL_H_ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +DECLARE_string(fst_field_separator); + +namespace fst { + +// Compile a binary Fst from textual input, helper class for fstcompile.cc +// WARNING: Stand-alone use of this class not recommended, most code should +// read/write using the binary format which is much more efficient. +template +class FstCompiler { + public: + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + // WARNING: use of negative labels not recommended as it may cause conflicts. + // If add_symbols_ is true, then the symbols will be dynamically added to the + // symbol tables. This is only useful if you set the (i/o)keep flag to attach + // the final symbol table, or use the accessors. (The input symbol tables are + // const and therefore not changed.) + FstCompiler(std::istream &istrm, const string &source, // NOLINT + const SymbolTable *isyms, const SymbolTable *osyms, + const SymbolTable *ssyms, bool accep, bool ikeep, + bool okeep, bool nkeep, bool allow_negative_labels = false) { + std::unique_ptr misyms(isyms ? isyms->Copy() : nullptr); + std::unique_ptr mosyms(osyms ? osyms->Copy() : nullptr); + std::unique_ptr mssyms(ssyms ? ssyms->Copy() : nullptr); + Init(istrm, source, misyms.get(), mosyms.get(), mssyms.get(), accep, + ikeep, okeep, nkeep, allow_negative_labels, false); + } + + FstCompiler(std::istream &istrm, const string &source, // NOLINT + SymbolTable *isyms, SymbolTable *osyms, SymbolTable *ssyms, + bool accep, bool ikeep, bool okeep, bool nkeep, + bool allow_negative_labels, bool add_symbols) { + Init(istrm, source, isyms, osyms, ssyms, accep, ikeep, okeep, nkeep, + allow_negative_labels, add_symbols); + } + + void Init(std::istream &istrm, const string &source, // NOLINT + SymbolTable *isyms, SymbolTable *osyms, SymbolTable *ssyms, + bool accep, bool ikeep, bool okeep, bool nkeep, + bool allow_negative_labels, bool add_symbols) { + nline_ = 0; + source_ = source; + isyms_ = isyms; + osyms_ = osyms; + ssyms_ = ssyms; + nstates_ = 0; + keep_state_numbering_ = nkeep; + allow_negative_labels_ = allow_negative_labels; + add_symbols_ = add_symbols; + bool start_state_populated = false; + char line[kLineLen]; + const string separator = FLAGS_fst_field_separator + "\n"; + while (istrm.getline(line, kLineLen)) { + ++nline_; + std::vector col; + SplitString(line, separator.c_str(), &col, true); + if (col.empty() || col[0][0] == '\0') + continue; + if (col.size() > 5 || (col.size() > 4 && accep) || + (col.size() == 3 && !accep)) { + FSTERROR() << "FstCompiler: Bad number of columns, source = " << source_ + << ", line = " << nline_; + fst_.SetProperties(kError, kError); + return; + } + StateId s = StrToStateId(col[0]); + while (s >= fst_.NumStates()) fst_.AddState(); + if (!start_state_populated) { + fst_.SetStart(s); + start_state_populated = true; + } + + Arc arc; + StateId d = s; + switch (col.size()) { + case 1: + fst_.SetFinal(s, Weight::One()); + break; + case 2: + fst_.SetFinal(s, StrToWeight(col[1], true)); + break; + case 3: + arc.nextstate = d = StrToStateId(col[1]); + arc.ilabel = StrToILabel(col[2]); + arc.olabel = arc.ilabel; + arc.weight = Weight::One(); + fst_.AddArc(s, arc); + break; + case 4: + arc.nextstate = d = StrToStateId(col[1]); + arc.ilabel = StrToILabel(col[2]); + if (accep) { + arc.olabel = arc.ilabel; + arc.weight = StrToWeight(col[3], true); + } else { + arc.olabel = StrToOLabel(col[3]); + arc.weight = Weight::One(); + } + fst_.AddArc(s, arc); + break; + case 5: + arc.nextstate = d = StrToStateId(col[1]); + arc.ilabel = StrToILabel(col[2]); + arc.olabel = StrToOLabel(col[3]); + arc.weight = StrToWeight(col[4], true); + fst_.AddArc(s, arc); + } + while (d >= fst_.NumStates()) fst_.AddState(); + } + if (ikeep) fst_.SetInputSymbols(isyms); + if (okeep) fst_.SetOutputSymbols(osyms); + } + + const VectorFst &Fst() const { return fst_; } + + private: + // Maximum line length in text file. + static constexpr int kLineLen = 8096; + + StateId StrToId(const char *s, SymbolTable *syms, const char *name, + bool allow_negative = false) const { + StateId n = 0; + if (syms) { + n = (add_symbols_) ? syms->AddSymbol(s) : syms->Find(s); + if (n == -1 || (!allow_negative && n < 0)) { + FSTERROR() << "FstCompiler: Symbol \"" << s + << "\" is not mapped to any integer " << name + << ", symbol table = " << syms->Name() + << ", source = " << source_ << ", line = " << nline_; + fst_.SetProperties(kError, kError); + } + } else { + char *p; + n = strtoll(s, &p, 10); + if (p < s + strlen(s) || (!allow_negative && n < 0)) { + FSTERROR() << "FstCompiler: Bad " << name << " integer = \"" << s + << "\", source = " << source_ << ", line = " << nline_; + fst_.SetProperties(kError, kError); + } + } + return n; + } + + StateId StrToStateId(const char *s) { + StateId n = StrToId(s, ssyms_, "state ID"); + if (keep_state_numbering_) return n; + // Remaps state IDs to make dense set. + const auto it = states_.find(n); + if (it == states_.end()) { + states_[n] = nstates_; + return nstates_++; + } else { + return it->second; + } + } + + StateId StrToILabel(const char *s) const { + return StrToId(s, isyms_, "arc ilabel", allow_negative_labels_); + } + + StateId StrToOLabel(const char *s) const { + return StrToId(s, osyms_, "arc olabel", allow_negative_labels_); + } + + Weight StrToWeight(const char *s, bool allow_zero) const { + Weight w; + std::istringstream strm(s); + strm >> w; + if (!strm || (!allow_zero && w == Weight::Zero())) { + FSTERROR() << "FstCompiler: Bad weight = \"" << s + << "\", source = " << source_ << ", line = " << nline_; + fst_.SetProperties(kError, kError); + w = Weight::NoWeight(); + } + return w; + } + + mutable VectorFst fst_; + size_t nline_; + string source_; // Text FST source name. + SymbolTable *isyms_; // ilabel symbol table (not owned). + SymbolTable *osyms_; // olabel symbol table (not owned). + SymbolTable *ssyms_; // slabel symbol table (not owned). + std::unordered_map states_; // State ID map. + StateId nstates_; // Number of seen states. + bool keep_state_numbering_; + bool allow_negative_labels_; // Not recommended; may cause conflicts. + bool add_symbols_; // Add to symbol tables on-the fly. + + FstCompiler(const FstCompiler &) = delete; + FstCompiler &operator=(const FstCompiler &) = delete; +}; + +} // namespace fst + +#endif // FST_SCRIPT_COMPILE_IMPL_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/compile.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/compile.h new file mode 100644 index 0000000000..c82ed4777c --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/compile.h @@ -0,0 +1,98 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_COMPILE_H_ +#define FST_SCRIPT_COMPILE_H_ + +#include +#include + +#include +#include +#include + +namespace fst { +namespace script { + +// This operation exists in two forms. 1 is a void operation which writes the +// compiled machine to disk; 2 returns an FstClass. I/O should normally be done +// using the binary format for efficiency, so users are STRONGLY ENCOURAGED to +// use 1 or to construct FSTs using the C++ FST mutation operations. + +// Note: it is safe to pass these strings as references because +// this struct is only used to pass them deeper in the call graph. +// Be sure you understand why this is so before using this struct +// for anything else! +struct CompileFstInnerArgs { + std::istream &istrm; + const string &source; + const string &fst_type; + const fst::SymbolTable *isyms; + const fst::SymbolTable *osyms; + const fst::SymbolTable *ssyms; + const bool accep; + const bool ikeep; + const bool okeep; + const bool nkeep; + const bool allow_negative_labels; + + CompileFstInnerArgs(std::istream &istrm, const string &source, + const string &fst_type, const fst::SymbolTable *isyms, + const fst::SymbolTable *osyms, + const fst::SymbolTable *ssyms, bool accep, bool ikeep, + bool okeep, bool nkeep, + bool allow_negative_labels = false) + : istrm(istrm), + source(source), + fst_type(fst_type), + isyms(isyms), + osyms(osyms), + ssyms(ssyms), + accep(accep), + ikeep(ikeep), + okeep(okeep), + nkeep(nkeep), + allow_negative_labels(allow_negative_labels) {} +}; + +using CompileFstArgs = WithReturnValue; + +template +void CompileFstInternal(CompileFstArgs *args) { + using fst::Convert; + using fst::Fst; + using fst::FstCompiler; + FstCompiler fstcompiler( + args->args.istrm, args->args.source, args->args.isyms, args->args.osyms, + args->args.ssyms, args->args.accep, args->args.ikeep, args->args.okeep, + args->args.nkeep, args->args.allow_negative_labels); + const Fst *fst = &fstcompiler.Fst(); + std::unique_ptr> owned_fst; + if (args->args.fst_type != "vector") { + owned_fst.reset(Convert(*fst, args->args.fst_type)); + if (!owned_fst) { + FSTERROR() << "Failed to convert FST to desired type: " + << args->args.fst_type; + } + fst = owned_fst.get(); + } + args->retval = fst ? new FstClass(*fst) : nullptr; +} + +void CompileFst(std::istream &istrm, const string &source, const string &dest, + const string &fst_type, const string &arc_type, + const SymbolTable *isyms, const SymbolTable *osyms, + const SymbolTable *ssyms, bool accep, bool ikeep, bool okeep, + bool nkeep, bool allow_negative_labels); + +FstClass *CompileFstInternal(std::istream &istrm, const string &source, + const string &fst_type, const string &arc_type, + const SymbolTable *isyms, const SymbolTable *osyms, + const SymbolTable *ssyms, bool accep, bool ikeep, + bool okeep, bool nkeep, + bool allow_negative_labels); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_COMPILE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/compose.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/compose.h new file mode 100644 index 0000000000..a17358030c --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/compose.h @@ -0,0 +1,34 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_COMPOSE_H_ +#define FST_SCRIPT_COMPOSE_H_ + +#include + +#include +#include + +namespace fst { +namespace script { + +using ComposeArgs = std::tuple; + +template +void Compose(ComposeArgs *args) { + const Fst &ifst1 = *(std::get<0>(*args).GetFst()); + const Fst &ifst2 = *(std::get<1>(*args).GetFst()); + MutableFst *ofst = std::get<2>(*args)->GetMutableFst(); + const auto &opts = std::get<3>(*args); + Compose(ifst1, ifst2, ofst, opts); +} + +void Compose(const FstClass &ifst1, const FstClass &ifst2, + MutableFstClass *ofst, + const ComposeOptions &opts = ComposeOptions()); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_COMPOSE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/concat.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/concat.h new file mode 100644 index 0000000000..4bf8dc6118 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/concat.h @@ -0,0 +1,40 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_CONCAT_H_ +#define FST_SCRIPT_CONCAT_H_ + +#include + +#include +#include + +namespace fst { +namespace script { + +using ConcatArgs1 = std::pair; + +template +void Concat(ConcatArgs1 *args) { + MutableFst *ofst = std::get<0>(*args)->GetMutableFst(); + const Fst &ifst = *(std::get<1>(*args).GetFst()); + Concat(ofst, ifst); +} + +using ConcatArgs2 = std::pair; + +template +void Concat(ConcatArgs2 *args) { + const Fst &ifst = *(std::get<0>(*args).GetFst()); + MutableFst *ofst = std::get<1>(*args)->GetMutableFst(); + Concat(ifst, ofst); +} + +void Concat(MutableFstClass *ofst, const FstClass &ifst); + +void Concat(const FstClass &ifst, MutableFstClass *ofst); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_CONCAT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/connect.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/connect.h new file mode 100644 index 0000000000..030102acd0 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/connect.h @@ -0,0 +1,23 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_CONNECT_H_ +#define FST_SCRIPT_CONNECT_H_ + +#include +#include + +namespace fst { +namespace script { + +template +void Connect(MutableFstClass *fst) { + Connect(fst->GetMutableFst()); +} + +void Connect(MutableFstClass *fst); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_CONNECT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/convert.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/convert.h new file mode 100644 index 0000000000..1a6eeaa37d --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/convert.h @@ -0,0 +1,35 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_CONVERT_H_ +#define FST_SCRIPT_CONVERT_H_ + +#include +#include +#include + +#include +#include +#include + +namespace fst { +namespace script { + +using ConvertInnerArgs = std::pair; + +using ConvertArgs = WithReturnValue; + +template +void Convert(ConvertArgs *args) { + const Fst &fst = *(std::get<0>(args->args).GetFst()); + const string &new_type = std::get<1>(args->args); + std::unique_ptr> result(Convert(fst, new_type)); + args->retval = result ? new FstClass(*result) : nullptr; +} + +FstClass *Convert(const FstClass &fst, const string &new_type); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_CONVERT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/decode.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/decode.h new file mode 100644 index 0000000000..09f2539154 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/decode.h @@ -0,0 +1,49 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_DECODE_H_ +#define FST_SCRIPT_DECODE_H_ + +#include +#include +#include + +#include +#include +#include + +namespace fst { +namespace script { + +using DecodeArgs1 = std::pair; + +template +void Decode(DecodeArgs1 *args) { + MutableFst *fst = std::get<0>(*args)->GetMutableFst(); + std::unique_ptr> decoder( + EncodeMapper::Read(std::get<1>(*args), DECODE)); + if (!decoder) { + fst->SetProperties(kError, kError); + return; + } + Decode(fst, *decoder); +} + +using DecodeArgs2 = std::pair; + +template +void Decode(DecodeArgs2 *args) { + MutableFst *fst = std::get<0>(*args)->GetMutableFst(); + const EncodeMapper &encoder = + *(std::get<1>(*args).GetEncodeMapper()); + Decode(fst, encoder); +} + +void Decode(MutableFstClass *fst, const string &coder_fname); + +void Decode(MutableFstClass *fst, const EncodeMapperClass &encoder); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_DECODE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/determinize.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/determinize.h new file mode 100644 index 0000000000..383a8fe4d9 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/determinize.h @@ -0,0 +1,59 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_DETERMINIZE_H_ +#define FST_SCRIPT_DETERMINIZE_H_ + +#include + +#include +#include +#include + +namespace fst { +namespace script { + +struct DeterminizeOptions { + const float delta; + const WeightClass &weight_threshold; + const int64 state_threshold; + const int64 subsequential_label; + const DeterminizeType det_type; + const bool increment_subsequential_label; + + DeterminizeOptions(float delta, const WeightClass &weight_threshold, + int64 state_threshold = kNoStateId, + int64 subsequential_label = 0, + DeterminizeType det_type = DETERMINIZE_FUNCTIONAL, + bool increment_subsequential_label = false) + : delta(delta), + weight_threshold(weight_threshold), + state_threshold(state_threshold), + subsequential_label(subsequential_label), + det_type(det_type), + increment_subsequential_label(increment_subsequential_label) {} +}; + +using DeterminizeArgs = std::tuple; + +template +void Determinize(DeterminizeArgs *args) { + using Weight = typename Arc::Weight; + const Fst &ifst = *(std::get<0>(*args).GetFst()); + MutableFst *ofst = std::get<1>(*args)->GetMutableFst(); + const auto &opts = std::get<2>(*args); + const auto weight_threshold = *(opts.weight_threshold.GetWeight()); + const fst::DeterminizeOptions detargs(opts.delta, weight_threshold, + opts.state_threshold, opts.subsequential_label, opts.det_type, + opts.increment_subsequential_label); + Determinize(ifst, ofst, detargs); +} + +void Determinize(const FstClass &ifst, MutableFstClass *ofst, + const DeterminizeOptions &opts); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_DETERMINIZE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/difference.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/difference.h new file mode 100644 index 0000000000..7af6200a85 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/difference.h @@ -0,0 +1,35 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_DIFFERENCE_H_ +#define FST_SCRIPT_DIFFERENCE_H_ + +#include + +#include +#include +#include + +namespace fst { +namespace script { + +using DifferenceArgs = std::tuple; + +template +void Difference(DifferenceArgs *args) { + const Fst &ifst1 = *(std::get<0>(*args).GetFst()); + const Fst &ifst2 = *(std::get<1>(*args).GetFst()); + MutableFst *ofst = std::get<2>(*args)->GetMutableFst(); + const auto &opts = std::get<3>(*args); + Difference(ifst1, ifst2, ofst, opts); +} + +void Difference(const FstClass &ifst1, const FstClass &ifst2, + MutableFstClass *ofst, + const ComposeOptions &opts = ComposeOptions()); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_DIFFERENCE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/disambiguate.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/disambiguate.h new file mode 100644 index 0000000000..acc1fba274 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/disambiguate.h @@ -0,0 +1,54 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_DISAMBIGUATE_H_ +#define FST_SCRIPT_DISAMBIGUATE_H_ + +#include +#include + +#include +#include +#include + +namespace fst { +namespace script { + +struct DisambiguateOptions { + const float delta; + const WeightClass &weight_threshold; + const int64 state_threshold; + const int64 subsequential_label; + + DisambiguateOptions(float delta, const WeightClass &weight_threshold, + int64 state_threshold = kNoStateId, + int64 subsequential_label = 0) + : delta(delta), + weight_threshold(weight_threshold), + state_threshold(state_threshold), + subsequential_label(subsequential_label) {} +}; + +using DisambiguateArgs = std::tuple; + +template +void Disambiguate(DisambiguateArgs *args) { + using Weight = typename Arc::Weight; + const Fst &ifst = *(std::get<0>(*args).GetFst()); + MutableFst *ofst = std::get<1>(*args)->GetMutableFst(); + const auto &opts = std::get<2>(*args); + const auto weight_threshold = *(opts.weight_threshold.GetWeight()); + const fst::DisambiguateOptions disargs(opts.delta, weight_threshold, + opts.state_threshold, + opts.subsequential_label); + Disambiguate(ifst, ofst, disargs); +} + +void Disambiguate(const FstClass &ifst, MutableFstClass *ofst, + const DisambiguateOptions &opts); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_DISAMBIGUATE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/draw-impl.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/draw-impl.h new file mode 100644 index 0000000000..f204b2e68a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/draw-impl.h @@ -0,0 +1,227 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Class to draw a binary FST by producing a text file in dot format, a helper +// class to fstdraw.cc. + +#ifndef FST_SCRIPT_DRAW_IMPL_H_ +#define FST_SCRIPT_DRAW_IMPL_H_ + +#include +#include +#include + +#include +#include +#include + +namespace fst { + +// Print a binary FST in GraphViz textual format (helper class for fstdraw.cc). +// WARNING: Stand-alone use not recommend. +template +class FstDrawer { + public: + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + FstDrawer(const Fst &fst, const SymbolTable *isyms, + const SymbolTable *osyms, const SymbolTable *ssyms, bool accep, + const string &title, float width, float height, bool portrait, + bool vertical, float ranksep, float nodesep, int fontsize, + int precision, const string &float_format, bool show_weight_one) + : fst_(fst), + isyms_(isyms), + osyms_(osyms), + ssyms_(ssyms), + accep_(accep && fst.Properties(kAcceptor, true)), + ostrm_(nullptr), + title_(title), + width_(width), + height_(height), + portrait_(portrait), + vertical_(vertical), + ranksep_(ranksep), + nodesep_(nodesep), + fontsize_(fontsize), + precision_(precision), + float_format_(float_format), + show_weight_one_(show_weight_one) {} + + // Draws FST to an output buffer. + void Draw(std::ostream *strm, const string &dest) { + ostrm_ = strm; + SetStreamState(ostrm_); + dest_ = dest; + StateId start = fst_.Start(); + if (start == kNoStateId) return; + PrintString("digraph FST {\n"); + if (vertical_) { + PrintString("rankdir = BT;\n"); + } else { + PrintString("rankdir = LR;\n"); + } + PrintString("size = \""); + Print(width_); + PrintString(","); + Print(height_); + PrintString("\";\n"); + if (!dest_.empty()) PrintString("label = \"" + title_ + "\";\n"); + PrintString("center = 1;\n"); + if (portrait_) { + PrintString("orientation = Portrait;\n"); + } else { + PrintString("orientation = Landscape;\n"); + } + PrintString("ranksep = \""); + Print(ranksep_); + PrintString("\";\n"); + PrintString("nodesep = \""); + Print(nodesep_); + PrintString("\";\n"); + // Initial state first. + DrawState(start); + for (StateIterator> siter(fst_); !siter.Done(); siter.Next()) { + const auto s = siter.Value(); + if (s != start) DrawState(s); + } + PrintString("}\n"); + } + + private: + void SetStreamState(std::ostream* strm) const { + strm->precision(precision_); + if (float_format_ == "e") + strm->setf(std::ios_base::scientific, std::ios_base::floatfield); + if (float_format_ == "f") + strm->setf(std::ios_base::fixed, std::ios_base::floatfield); + // O.w. defaults to "g" per standard lib. + } + + void PrintString(const string &str) const { *ostrm_ << str; } + + // Escapes backslash and double quote if these occur in the string. Dot will + // not deal gracefully with these if they are not escaped. + static string Escape(const string &str) { + string ns; + for (char c : str) { + if (c == '\\' || c == '"') ns.push_back('\\'); + ns.push_back(c); + } + return ns; + } + + void PrintId(StateId id, const SymbolTable *syms, const char *name) const { + if (syms) { + auto symbol = syms->Find(id); + if (symbol.empty()) { + FSTERROR() << "FstDrawer: Integer " << id + << " is not mapped to any textual symbol" + << ", symbol table = " << syms->Name() + << ", destination = " << dest_; + symbol = "?"; + } + PrintString(Escape(symbol)); + } else { + PrintString(std::to_string(id)); + } + } + + void PrintStateId(StateId s) const { PrintId(s, ssyms_, "state ID"); } + + void PrintILabel(Label label) const { + PrintId(label, isyms_, "arc input label"); + } + + void PrintOLabel(Label label) const { + PrintId(label, osyms_, "arc output label"); + } + + void PrintWeight(Weight w) const { + // Weight may have double quote characters in it, so escape it. + PrintString(Escape(ToString(w))); + } + + template + void Print(T t) const { *ostrm_ << t; } + + template + string ToString(T t) const { + std::stringstream ss; + SetStreamState(&ss); + ss << t; + return ss.str(); + } + + void DrawState(StateId s) const { + Print(s); + PrintString(" [label = \""); + PrintStateId(s); + const auto weight = fst_.Final(s); + if (weight != Weight::Zero()) { + if (show_weight_one_ || (weight != Weight::One())) { + PrintString("/"); + PrintWeight(weight); + } + PrintString("\", shape = doublecircle,"); + } else { + PrintString("\", shape = circle,"); + } + if (s == fst_.Start()) { + PrintString(" style = bold,"); + } else { + PrintString(" style = solid,"); + } + PrintString(" fontsize = "); + Print(fontsize_); + PrintString("]\n"); + for (ArcIterator> aiter(fst_, s); !aiter.Done(); aiter.Next()) { + const auto &arc = aiter.Value(); + PrintString("\t"); + Print(s); + PrintString(" -> "); + Print(arc.nextstate); + PrintString(" [label = \""); + PrintILabel(arc.ilabel); + if (!accep_) { + PrintString(":"); + PrintOLabel(arc.olabel); + } + if (show_weight_one_ || (arc.weight != Weight::One())) { + PrintString("/"); + PrintWeight(arc.weight); + } + PrintString("\", fontsize = "); + Print(fontsize_); + PrintString("];\n"); + } + } + + const Fst &fst_; + const SymbolTable *isyms_; // ilabel symbol table. + const SymbolTable *osyms_; // olabel symbol table. + const SymbolTable *ssyms_; // slabel symbol table. + bool accep_; // Print as acceptor when possible. + std::ostream *ostrm_; // Drawn FST destination. + string dest_; // Drawn FST destination name. + + string title_; + float width_; + float height_; + bool portrait_; + bool vertical_; + float ranksep_; + float nodesep_; + int fontsize_; + int precision_; + string float_format_; + bool show_weight_one_; + + FstDrawer(const FstDrawer &) = delete; + FstDrawer &operator=(const FstDrawer &) = delete; +}; + +} // namespace fst + +#endif // FST_SCRIPT_DRAW_IMPL_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/draw.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/draw.h new file mode 100644 index 0000000000..cb37df1e8d --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/draw.h @@ -0,0 +1,85 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_DRAW_H_ +#define FST_SCRIPT_DRAW_H_ + +#include + +#include +#include + +namespace fst { +namespace script { + +// Note: it is safe to pass these strings as references because +// this struct is only used to pass them deeper in the call graph. +// Be sure you understand why this is so before using this struct +// for anything else! +struct FstDrawerArgs { + const FstClass &fst; + const SymbolTable *isyms; + const SymbolTable *osyms; + const SymbolTable *ssyms; + const bool accep; + const string &title; + const float width; + const float height; + const bool portrait; + const bool vertical; + const float ranksep; + const float nodesep; + const int fontsize; + const int precision; + const string &float_format; // NOLINT + const bool show_weight_one; + std::ostream *ostrm; + const string &dest; + + FstDrawerArgs(const FstClass &fst, const SymbolTable *isyms, + const SymbolTable *osyms, const SymbolTable *ssyms, bool accep, + const string &title, float width, float height, bool portrait, + bool vertical, float ranksep, float nodesep, int fontsize, + int precision, const string &float_format, + bool show_weight_one, std::ostream *ostrm, const string &dest) + : fst(fst), + isyms(isyms), + osyms(osyms), + ssyms(ssyms), + accep(accep), + title(title), + width(width), + height(height), + portrait(portrait), + vertical(vertical), + ranksep(ranksep), + nodesep(nodesep), + fontsize(fontsize), + precision(precision), + float_format(float_format), + show_weight_one(show_weight_one), + ostrm(ostrm), + dest(dest) {} +}; + +template +void DrawFst(FstDrawerArgs *args) { + const Fst &fst = *(args->fst.GetFst()); + FstDrawer fstdrawer(fst, args->isyms, args->osyms, args->ssyms, + args->accep, args->title, args->width, args->height, args->portrait, + args->vertical, args->ranksep, args->nodesep, args->fontsize, + args->precision, args->float_format, args->show_weight_one); + fstdrawer.Draw(args->ostrm, args->dest); +} + +void DrawFst(const FstClass &fst, const SymbolTable *isyms, + const SymbolTable *osyms, const SymbolTable *ssyms, bool accep, + const string &title, float width, float height, bool portrait, + bool vertical, float ranksep, float nodesep, int fontsize, + int precision, const string &float_format, bool show_weight_one, + std::ostream *ostrm, const string &dest); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_DRAW_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/encode.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/encode.h new file mode 100644 index 0000000000..6a869680fe --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/encode.h @@ -0,0 +1,51 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_ENCODE_H_ +#define FST_SCRIPT_ENCODE_H_ + +#include +#include +#include +#include + +#include +#include +#include + +namespace fst { +namespace script { + +using EncodeArgs1 = std::tuple; + +template +void Encode(EncodeArgs1 *args) { + MutableFst *fst = std::get<0>(*args)->GetMutableFst(); + const string &coder_fname = std::get<3>(*args); + // If true, reuse encode from disk. If false, make a new encoder and just use + // the filename argument as the destination state. + std::unique_ptr> encoder( + std::get<2>(*args) ? EncodeMapper::Read(coder_fname, ENCODE) + : new EncodeMapper(std::get<1>(*args), ENCODE)); + Encode(fst, encoder.get()); + if (!std::get<2>(*args)) encoder->Write(coder_fname); +} + +using EncodeArgs2 = std::pair; + +template +void Encode(EncodeArgs2 *args) { + MutableFst *fst = std::get<0>(*args)->GetMutableFst(); + EncodeMapper *encoder = std::get<1>(*args)->GetEncodeMapper(); + Encode(fst, encoder); +} + +void Encode(MutableFstClass *fst, uint32 flags, bool reuse_encoder, + const string &coder_fname); + +void Encode(MutableFstClass *fst, EncodeMapperClass *encoder); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_ENCODE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/encodemapper-class.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/encodemapper-class.h new file mode 100644 index 0000000000..b62824f10c --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/encodemapper-class.h @@ -0,0 +1,169 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_ENCODEMAPPER_CLASS_H_ +#define FST_SCRIPT_ENCODEMAPPER_CLASS_H_ + +#include +#include +#include + +#include +#include +#include + +// Scripting API support for EncodeMapper. + +namespace fst { +namespace script { + +// Virtual interface implemented by each concrete EncodeMapperClassImpl. +class EncodeMapperImplBase { + public: + // Returns an encoded ArcClass. + virtual ArcClass operator()(const ArcClass &a) = 0; + virtual const string &ArcType() const = 0; + virtual uint32 Flags() const = 0; + virtual uint64 Properties(uint64 inprops) = 0; + virtual EncodeType Type() const = 0; + virtual const SymbolTable *InputSymbols() const = 0; + virtual const SymbolTable *OutputSymbols() const = 0; + virtual void SetInputSymbols(const SymbolTable *syms) = 0; + virtual void SetOutputSymbols(const SymbolTable *syms) = 0; + virtual const string &WeightType() const = 0; + virtual ~EncodeMapperImplBase() {} +}; + +// Templated implementation. +template +class EncodeMapperClassImpl : public EncodeMapperImplBase { + public: + EncodeMapperClassImpl(uint32 flags, EncodeType type) + : encoder_(flags, type) {} + + ArcClass operator()(const ArcClass &a) final; + + const string &ArcType() const final { return Arc::Type(); } + + uint32 Flags() const final { return encoder_.Flags(); } + + uint64 Properties(uint64 inprops) final { + return encoder_.Properties(inprops); + } + + EncodeType Type() const final { return encoder_.Type(); } + + const SymbolTable *InputSymbols() const final { + return encoder_.InputSymbols(); + } + + const SymbolTable *OutputSymbols() const final { + return encoder_.OutputSymbols(); + } + + void SetInputSymbols(const SymbolTable *syms) final { + encoder_.SetInputSymbols(syms); + } + + void SetOutputSymbols(const SymbolTable *syms) final { + encoder_.SetOutputSymbols(syms); + } + + const string &WeightType() const final { return Arc::Weight::Type(); } + + ~EncodeMapperClassImpl() override {} + + EncodeMapper *GetImpl() const { return &encoder_; } + + EncodeMapper *GetImpl() { return &encoder_; } + + private: + EncodeMapper encoder_; +}; + +// This is returned by value because it is very likely to undergo return-value +// optimization. +template +inline ArcClass EncodeMapperClassImpl::operator()(const ArcClass &a) { + Arc arc(a.ilabel, a.olabel, *(a.weight.GetWeight()), + a.nextstate); + return ArcClass(encoder_(arc)); +} + +class EncodeMapperClass; + +using InitEncodeMapperClassArgs = + std::tuple; + +class EncodeMapperClass { + public: + EncodeMapperClass(const string &arc_type, uint32 flags, EncodeType type); + + template + EncodeMapperClass(uint32 flags, EncodeType type) + : impl_(new EncodeMapperClassImpl(flags, type)) {} + + ArcClass operator()(const ArcClass &arc) { return (*impl_)(arc); } + + const string &ArcType() const { return impl_->ArcType(); } + + uint32 Flags() const { return impl_->Flags(); } + + uint64 Properties(uint64 inprops) { return impl_->Properties(inprops); } + + EncodeType Type() const { return impl_->Type(); } + + const SymbolTable *InputSymbols() const { return impl_->InputSymbols(); } + + const SymbolTable *OutputSymbols() const { return impl_->OutputSymbols(); } + + void SetInputSymbols(const SymbolTable *syms) { + impl_->SetInputSymbols(syms); + } + + void SetOutputSymbols(const SymbolTable *syms) { + impl_->SetOutputSymbols(syms); + } + + const string &WeightType() const { return impl_->WeightType(); } + + template + friend void InitEncodeMapperClass(InitEncodeMapperClassArgs *args); + + // Naturally, this exists in non-const and const forms. Encoding arcs or FSTs + // mutates the underlying encoder; decoding them does not. + + template + EncodeMapper *GetEncodeMapper() { + if (Arc::Type() != ArcType()) { + return nullptr; + } else { + auto *typed_impl = static_cast *>(impl_.get()); + return typed_impl->GetImpl(); + } + } + + template + const EncodeMapper *GetEncodeMapper() const { + if (Arc::Type() != ArcType()) { + return nullptr; + } else { + auto *typed_impl = static_cast *>(impl_.get()); + return typed_impl->GetImpl(); + } + } + + private: + std::unique_ptr impl_; +}; + +template +void InitEncodeMapperClass(InitEncodeMapperClassArgs *args) { + std::get<2>(*args)->impl_.reset( + new EncodeMapperClassImpl(std::get<0>(*args), std::get<1>(*args))); +} + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_ENCODEMAPPER_CLASS_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/epsnormalize.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/epsnormalize.h new file mode 100644 index 0000000000..b55fefae0b --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/epsnormalize.h @@ -0,0 +1,31 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_EPSNORMALIZE_H_ +#define FST_SCRIPT_EPSNORMALIZE_H_ + +#include + +#include +#include + +namespace fst { +namespace script { + +using EpsNormalizeArgs = std::tuple; + +template +void EpsNormalize(EpsNormalizeArgs *args) { + const Fst &ifst = *(std::get<0>(*args).GetFst()); + MutableFst *ofst = std::get<1>(*args)->GetMutableFst(); + EpsNormalize(ifst, ofst, std::get<2>(*args)); +} + +void EpsNormalize(const FstClass &ifst, MutableFstClass *ofst, + EpsNormalizeType norm_type = EPS_NORM_INPUT); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_EPSNORMALIZE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/equal.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/equal.h new file mode 100644 index 0000000000..79ea9aa463 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/equal.h @@ -0,0 +1,32 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_EQUAL_H_ +#define FST_SCRIPT_EQUAL_H_ + +#include + +#include +#include +#include + +namespace fst { +namespace script { + +using EqualInnerArgs = std::tuple; + +using EqualArgs = WithReturnValue; + +template +void Equal(EqualArgs *args) { + const Fst &fst1 = *(std::get<0>(args->args).GetFst()); + const Fst &fst2 = *(std::get<1>(args->args).GetFst()); + args->retval = Equal(fst1, fst2, std::get<2>(args->args)); +} + +bool Equal(const FstClass &fst1, const FstClass &fst2, float delta = kDelta); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_EQUAL_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/equivalent.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/equivalent.h new file mode 100644 index 0000000000..7cdff45e4d --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/equivalent.h @@ -0,0 +1,34 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_EQUIVALENT_H_ +#define FST_SCRIPT_EQUIVALENT_H_ + +#include + +#include +#include +#include + +namespace fst { +namespace script { + +using EquivalentInnerArgs = std::tuple; + +using EquivalentArgs = WithReturnValue; + +template +void Equivalent(EquivalentArgs *args) { + const Fst &fst1 = *(std::get<0>(args->args).GetFst()); + const Fst &fst2 = *(std::get<1>(args->args).GetFst()); + args->retval = Equivalent(fst1, fst2, std::get<2>(args->args)); +} + +bool Equivalent(const FstClass &fst1, const FstClass &fst2, + float delta = kDelta); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_EQUIVALENT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/fst-class.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/fst-class.h new file mode 100644 index 0000000000..07319fc72b --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/fst-class.h @@ -0,0 +1,530 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_FST_CLASS_H_ +#define FST_SCRIPT_FST_CLASS_H_ + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +// Classes to support "boxing" all existing types of FST arcs in a single +// FstClass which hides the arc types. This allows clients to load +// and work with FSTs without knowing the arc type. These classes are only +// recommended for use in high-level scripting applications. Most users should +// use the lower-level templated versions corresponding to these classes. + +namespace fst { +namespace script { + +// Abstract base class defining the set of functionalities implemented in all +// impls and passed through by all bases. Below FstClassBase the class +// hierarchy bifurcates; FstClassImplBase serves as the base class for all +// implementations (of which FstClassImpl is currently the only one) and +// FstClass serves as the base class for all interfaces. + +class FstClassBase { + public: + virtual const string &ArcType() const = 0; + virtual WeightClass Final(int64) const = 0; + virtual const string &FstType() const = 0; + virtual const SymbolTable *InputSymbols() const = 0; + virtual size_t NumArcs(int64) const = 0; + virtual size_t NumInputEpsilons(int64) const = 0; + virtual size_t NumOutputEpsilons(int64) const = 0; + virtual const SymbolTable *OutputSymbols() const = 0; + virtual uint64 Properties(uint64, bool) const = 0; + virtual int64 Start() const = 0; + virtual const string &WeightType() const = 0; + virtual bool ValidStateId(int64) const = 0; + virtual bool Write(const string &) const = 0; + virtual bool Write(std::ostream &, const string &) const = 0; + virtual ~FstClassBase() {} +}; + +// Adds all the MutableFst methods. +class FstClassImplBase : public FstClassBase { + public: + virtual bool AddArc(int64, const ArcClass &) = 0; + virtual int64 AddState() = 0; + virtual FstClassImplBase *Copy() = 0; + virtual bool DeleteArcs(int64, size_t) = 0; + virtual bool DeleteArcs(int64) = 0; + virtual bool DeleteStates(const std::vector &) = 0; + virtual void DeleteStates() = 0; + virtual SymbolTable *MutableInputSymbols() = 0; + virtual SymbolTable *MutableOutputSymbols() = 0; + virtual int64 NumStates() const = 0; + virtual bool ReserveArcs(int64, size_t) = 0; + virtual void ReserveStates(int64) = 0; + virtual void SetInputSymbols(SymbolTable *) = 0; + virtual bool SetFinal(int64, const WeightClass &) = 0; + virtual void SetOutputSymbols(SymbolTable *) = 0; + virtual void SetProperties(uint64, uint64) = 0; + virtual bool SetStart(int64) = 0; + ~FstClassImplBase() override {} +}; + +// Containiner class wrapping an Fst, hiding its arc type. Whether this +// Fst pointer refers to a special kind of FST (e.g. a MutableFst) is +// known by the type of interface class that owns the pointer to this +// container. + +template +class FstClassImpl : public FstClassImplBase { + public: + explicit FstClassImpl(Fst *impl, bool should_own = false) + : impl_(should_own ? impl : impl->Copy()) {} + + explicit FstClassImpl(const Fst &impl) : impl_(impl.Copy()) {} + + // Warning: calling this method casts the FST to a mutable FST. + bool AddArc(int64 s, const ArcClass &ac) final { + if (!ValidStateId(s)) return false; + // Note that we do not check that the destination state is valid, so users + // can add arcs before they add the corresponding states. Verify can be + // used to determine whether any arc has a nonexisting destination. + Arc arc(ac.ilabel, ac.olabel, *ac.weight.GetWeight(), + ac.nextstate); + static_cast *>(impl_.get())->AddArc(s, arc); + return true; + } + + // Warning: calling this method casts the FST to a mutable FST. + int64 AddState() final { + return static_cast *>(impl_.get())->AddState(); + } + + const string &ArcType() const final { return Arc::Type(); } + + FstClassImpl *Copy() final { return new FstClassImpl(impl_.get()); } + + // Warning: calling this method casts the FST to a mutable FST. + bool DeleteArcs(int64 s, size_t n) final { + if (!ValidStateId(s)) return false; + static_cast *>(impl_.get())->DeleteArcs(s, n); + return true; + } + + // Warning: calling this method casts the FST to a mutable FST. + bool DeleteArcs(int64 s) final { + if (!ValidStateId(s)) return false; + static_cast *>(impl_.get())->DeleteArcs(s); + return true; + } + + // Warning: calling this method casts the FST to a mutable FST. + bool DeleteStates(const std::vector &dstates) final { + for (const auto &state : dstates) + if (!ValidStateId(state)) return false; + // Warning: calling this method with any integers beyond the precision of + // the underlying FST will result in truncation. + std::vector typed_dstates(dstates.size()); + std::copy(dstates.begin(), dstates.end(), typed_dstates.begin()); + static_cast *>(impl_.get())->DeleteStates(typed_dstates); + return true; + } + + // Warning: calling this method casts the FST to a mutable FST. + void DeleteStates() final { + static_cast *>(impl_.get())->DeleteStates(); + } + + WeightClass Final(int64 s) const final { + if (!ValidStateId(s)) return WeightClass::NoWeight(WeightType()); + WeightClass w(impl_->Final(s)); + return w; + } + + const string &FstType() const final { return impl_->Type(); } + + const SymbolTable *InputSymbols() const final { + return impl_->InputSymbols(); + } + + // Warning: calling this method casts the FST to a mutable FST. + SymbolTable *MutableInputSymbols() final { + return static_cast *>(impl_.get())->MutableInputSymbols(); + } + + // Warning: calling this method casts the FST to a mutable FST. + SymbolTable *MutableOutputSymbols() final { + return static_cast *>(impl_.get())->MutableOutputSymbols(); + } + + // Signals failure by returning size_t max. + size_t NumArcs(int64 s) const final { + return ValidStateId(s) ? impl_->NumArcs(s) + : std::numeric_limits::max(); + } + + // Signals failure by returning size_t max. + size_t NumInputEpsilons(int64 s) const final { + return ValidStateId(s) ? impl_->NumInputEpsilons(s) + : std::numeric_limits::max(); + } + + // Signals failure by returning size_t max. + size_t NumOutputEpsilons(int64 s) const final { + return ValidStateId(s) ? impl_->NumOutputEpsilons(s) + : std::numeric_limits::max(); + } + + // Warning: calling this method casts the FST to a mutable FST. + int64 NumStates() const final { + return static_cast *>(impl_.get())->NumStates(); + } + + uint64 Properties(uint64 mask, bool test) const final { + return impl_->Properties(mask, test); + } + + // Warning: calling this method casts the FST to a mutable FST. + bool ReserveArcs(int64 s, size_t n) final { + if (!ValidStateId(s)) return false; + static_cast *>(impl_.get())->ReserveArcs(s, n); + return true; + } + + // Warning: calling this method casts the FST to a mutable FST. + void ReserveStates(int64 s) final { + static_cast *>(impl_.get())->ReserveStates(s); + } + + const SymbolTable *OutputSymbols() const final { + return impl_->OutputSymbols(); + } + + // Warning: calling this method casts the FST to a mutable FST. + void SetInputSymbols(SymbolTable *isyms) final { + static_cast *>(impl_.get())->SetInputSymbols(isyms); + } + + // Warning: calling this method casts the FST to a mutable FST. + bool SetFinal(int64 s, const WeightClass &weight) final { + if (!ValidStateId(s)) return false; + static_cast *>(impl_.get()) + ->SetFinal(s, *weight.GetWeight()); + return true; + } + + // Warning: calling this method casts the FST to a mutable FST. + void SetOutputSymbols(SymbolTable *osyms) final { + static_cast *>(impl_.get())->SetOutputSymbols(osyms); + } + + // Warning: calling this method casts the FST to a mutable FST. + void SetProperties(uint64 props, uint64 mask) final { + static_cast *>(impl_.get())->SetProperties(props, mask); + } + + // Warning: calling this method casts the FST to a mutable FST. + bool SetStart(int64 s) final { + if (!ValidStateId(s)) return false; + static_cast *>(impl_.get())->SetStart(s); + return true; + } + + int64 Start() const final { return impl_->Start(); } + + bool ValidStateId(int64 s) const final { + // This cowardly refuses to count states if the FST is not yet expanded. + if (!Properties(kExpanded, true)) { + FSTERROR() << "Cannot get number of states for unexpanded FST"; + return false; + } + // If the FST is already expanded, CountStates calls NumStates. + if (s < 0 || s >= CountStates(*impl_)) { + FSTERROR() << "State ID " << s << " not valid"; + return false; + } + return true; + } + + const string &WeightType() const final { return Arc::Weight::Type(); } + + bool Write(const string &fname) const final { return impl_->Write(fname); } + + bool Write(std::ostream &ostr, const string &fname) const final { + const FstWriteOptions opts(fname); + return impl_->Write(ostr, opts); + } + + ~FstClassImpl() override {} + + Fst *GetImpl() const { return impl_.get(); } + + private: + std::unique_ptr> impl_; +}; + +// BASE CLASS DEFINITIONS + +class MutableFstClass; + +class FstClass : public FstClassBase { + public: + FstClass() : impl_(nullptr) {} + + template + explicit FstClass(const Fst &fst) : impl_(new FstClassImpl(fst)) {} + + FstClass(const FstClass &other) + : impl_(other.impl_ == nullptr ? nullptr : other.impl_->Copy()) {} + + FstClass &operator=(const FstClass &other) { + impl_.reset(other.impl_ == nullptr ? nullptr : other.impl_->Copy()); + return *this; + } + + WeightClass Final(int64 s) const final { return impl_->Final(s); } + + const string &ArcType() const final { return impl_->ArcType(); } + + const string &FstType() const final { return impl_->FstType(); } + + const SymbolTable *InputSymbols() const final { + return impl_->InputSymbols(); + } + + size_t NumArcs(int64 s) const final { return impl_->NumArcs(s); } + + size_t NumInputEpsilons(int64 s) const final { + return impl_->NumInputEpsilons(s); + } + + size_t NumOutputEpsilons(int64 s) const final { + return impl_->NumOutputEpsilons(s); + } + + const SymbolTable *OutputSymbols() const final { + return impl_->OutputSymbols(); + } + + uint64 Properties(uint64 mask, bool test) const final { + // Special handling for FSTs with a null impl. + if (!impl_) return kError & mask; + return impl_->Properties(mask, test); + } + + static FstClass *Read(const string &fname); + + static FstClass *Read(std::istream &istrm, const string &source); + + int64 Start() const final { return impl_->Start(); } + + bool ValidStateId(int64 s) const final { return impl_->ValidStateId(s); } + + const string &WeightType() const final { return impl_->WeightType(); } + + // Helper that logs an ERROR if the weight type of an FST and a WeightClass + // don't match. + + bool WeightTypesMatch(const WeightClass &weight, const string &op_name) const; + + bool Write(const string &fname) const final { return impl_->Write(fname); } + + bool Write(std::ostream &ostr, const string &fname) const final { + return impl_->Write(ostr, fname); + } + + ~FstClass() override {} + + // These methods are required by IO registration. + + template + static FstClassImplBase *Convert(const FstClass &other) { + FSTERROR() << "Doesn't make sense to convert any class to type FstClass"; + return nullptr; + } + + template + static FstClassImplBase *Create() { + FSTERROR() << "Doesn't make sense to create an FstClass with a " + << "particular arc type"; + return nullptr; + } + + template + const Fst *GetFst() const { + if (Arc::Type() != ArcType()) { + return nullptr; + } else { + FstClassImpl *typed_impl = + static_cast *>(impl_.get()); + return typed_impl->GetImpl(); + } + } + + template + static FstClass *Read(std::istream &stream, const FstReadOptions &opts) { + if (!opts.header) { + LOG(ERROR) << "FstClass::Read: Options header not specified"; + return nullptr; + } + const FstHeader &hdr = *opts.header; + if (hdr.Properties() & kMutable) { + return ReadTypedFst>(stream, opts); + } else { + return ReadTypedFst>(stream, opts); + } + } + + protected: + explicit FstClass(FstClassImplBase *impl) : impl_(impl) {} + + const FstClassImplBase *GetImpl() const { return impl_.get(); } + + FstClassImplBase *GetImpl() { return impl_.get(); } + + // Generic template method for reading an arc-templated FST of type + // UnderlyingT, and returning it wrapped as FstClassT, with appropriat + // error checking. Called from arc-templated Read() static methods. + template + static FstClassT *ReadTypedFst(std::istream &stream, + const FstReadOptions &opts) { + std::unique_ptr u(UnderlyingT::Read(stream, opts)); + return u ? new FstClassT(*u) : nullptr; + } + + private: + std::unique_ptr impl_; +}; + +// Specific types of FstClass with special properties + +class MutableFstClass : public FstClass { + public: + bool AddArc(int64 s, const ArcClass &ac) { + if (!WeightTypesMatch(ac.weight, "AddArc")) return false; + return GetImpl()->AddArc(s, ac); + } + + int64 AddState() { return GetImpl()->AddState(); } + + bool DeleteArcs(int64 s, size_t n) { return GetImpl()->DeleteArcs(s, n); } + + bool DeleteArcs(int64 s) { return GetImpl()->DeleteArcs(s); } + + bool DeleteStates(const std::vector &dstates) { + return GetImpl()->DeleteStates(dstates); + } + + void DeleteStates() { GetImpl()->DeleteStates(); } + + SymbolTable *MutableInputSymbols() { + return GetImpl()->MutableInputSymbols(); + } + + SymbolTable *MutableOutputSymbols() { + return GetImpl()->MutableOutputSymbols(); + } + + int64 NumStates() const { return GetImpl()->NumStates(); } + + bool ReserveArcs(int64 s, size_t n) { return GetImpl()->ReserveArcs(s, n); } + + void ReserveStates(int64 s) { GetImpl()->ReserveStates(s); } + + static MutableFstClass *Read(const string &fname, bool convert = false); + + void SetInputSymbols(SymbolTable *isyms) { + GetImpl()->SetInputSymbols(isyms); + } + + bool SetFinal(int64 s, const WeightClass &weight) { + if (!WeightTypesMatch(weight, "SetFinal")) return false; + return GetImpl()->SetFinal(s, weight); + } + + void SetOutputSymbols(SymbolTable *osyms) { + GetImpl()->SetOutputSymbols(osyms); + } + + void SetProperties(uint64 props, uint64 mask) { + GetImpl()->SetProperties(props, mask); + } + + bool SetStart(int64 s) { return GetImpl()->SetStart(s); } + + template + explicit MutableFstClass(const MutableFst &fst) : FstClass(fst) {} + + // These methods are required by IO registration. + + template + static FstClassImplBase *Convert(const FstClass &other) { + FSTERROR() << "Doesn't make sense to convert any class to type " + << "MutableFstClass"; + return nullptr; + } + + template + static FstClassImplBase *Create() { + FSTERROR() << "Doesn't make sense to create a MutableFstClass with a " + << "particular arc type"; + return nullptr; + } + + template + MutableFst *GetMutableFst() { + Fst *fst = const_cast *>(this->GetFst()); + MutableFst *mfst = static_cast *>(fst); + return mfst; + } + + template + static MutableFstClass *Read(std::istream &stream, + const FstReadOptions &opts) { + std::unique_ptr> mfst(MutableFst::Read(stream, opts)); + return mfst ? new MutableFstClass(*mfst) : nullptr; + } + + protected: + explicit MutableFstClass(FstClassImplBase *impl) : FstClass(impl) {} +}; + +class VectorFstClass : public MutableFstClass { + public: + explicit VectorFstClass(FstClassImplBase *impl) : MutableFstClass(impl) {} + + explicit VectorFstClass(const FstClass &other); + + explicit VectorFstClass(const string &arc_type); + + static VectorFstClass *Read(const string &fname); + + template + static VectorFstClass *Read(std::istream &stream, + const FstReadOptions &opts) { + std::unique_ptr> mfst(VectorFst::Read(stream, opts)); + return mfst ? new VectorFstClass(*mfst) : nullptr; + } + + template + explicit VectorFstClass(const VectorFst &fst) : MutableFstClass(fst) {} + + template + static FstClassImplBase *Convert(const FstClass &other) { + return new FstClassImpl(new VectorFst(*other.GetFst()), + true); + } + + template + static FstClassImplBase *Create() { + return new FstClassImpl(new VectorFst(), true); + } +}; + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_FST_CLASS_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/fstscript-decl.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/fstscript-decl.h new file mode 100644 index 0000000000..294d0159dc --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/fstscript-decl.h @@ -0,0 +1,32 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Forward declarations for the FST and FST script classes. + +#ifndef FST_SCRIPT_FSTSCRIPT_DECL_H_ +#define FST_SCRIPT_FSTSCRIPT_DECL_H_ + +#include + +namespace fst { +namespace script { + +class ArcClass; + +class ArcIteratorClass; +class MutableArcIteratorClass; + +class EncodeMapperClass; + +class FstClass; +class MutableFstClass; +class VectorFstClass; + +class StateIteratorClass; + +class WeightClass; + +} // namespace script +} // namespace fst; + +#endif // FST_SCRIPT_FSTSCRIPT_DECL_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/fstscript.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/fstscript.h new file mode 100644 index 0000000000..45f161752c --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/fstscript.h @@ -0,0 +1,155 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// The FST script interface permits users to interact with FSTs without knowing +// their arc type. It does this by mapping compile-time polymorphism (in the +// form of a arc-templated FST types) onto a shared virtual interface. It also +// supports arc extension via a DSO interface. Due to the overhead of virtual +// dispatch and registered function lookups, the script API is somewhat slower +// then library API provided by types like StdVectorFst, but has the advantage +// that it is designed not to crash (and to provide useful debugging +// information) upon common user errors like passing invalid indices or +// attempting comparison of incompatible FSTs. It is used both by the FST +// binaries and the Python extension. +// +// This header includes all of the FST script functionality. + +#ifndef FST_SCRIPT_FSTSCRIPT_H_ +#define FST_SCRIPT_FSTSCRIPT_H_ + +// Major classes +#include +#include +#include +#include +#include +#include + +// Flag-to-enum parsers. +#include +// Templates like Operation<> and Apply<>. +#include + +// Operations. +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// This class is necessary because registering each of the operations +// separately overfills the stack, as there's so many of them. +namespace fst { +namespace script { + +template +class AllFstOperationsRegisterer { + public: + AllFstOperationsRegisterer() { + RegisterBatch1(); + RegisterBatch2(); + } + + private: + void RegisterBatch1() { + REGISTER_FST_OPERATION(ArcSort, Arc, ArcSortArgs); + REGISTER_FST_OPERATION(Closure, Arc, ClosureArgs); + REGISTER_FST_OPERATION(CompileFstInternal, Arc, CompileFstArgs); + REGISTER_FST_OPERATION(Compose, Arc, ComposeArgs); + REGISTER_FST_OPERATION(Concat, Arc, ConcatArgs1); + REGISTER_FST_OPERATION(Concat, Arc, ConcatArgs2); + REGISTER_FST_OPERATION(Connect, Arc, MutableFstClass); + REGISTER_FST_OPERATION(Convert, Arc, ConvertArgs); + REGISTER_FST_OPERATION(Decode, Arc, DecodeArgs1); + REGISTER_FST_OPERATION(Decode, Arc, DecodeArgs2); + REGISTER_FST_OPERATION(Determinize, Arc, DeterminizeArgs); + REGISTER_FST_OPERATION(Difference, Arc, DifferenceArgs); + REGISTER_FST_OPERATION(Disambiguate, Arc, DisambiguateArgs); + REGISTER_FST_OPERATION(DrawFst, Arc, FstDrawerArgs); + REGISTER_FST_OPERATION(Encode, Arc, EncodeArgs1); + REGISTER_FST_OPERATION(Encode, Arc, EncodeArgs2); + REGISTER_FST_OPERATION(EpsNormalize, Arc, EpsNormalizeArgs); + REGISTER_FST_OPERATION(Equal, Arc, EqualArgs); + REGISTER_FST_OPERATION(Equivalent, Arc, EquivalentArgs); + REGISTER_FST_OPERATION(PrintFstInfo, Arc, InfoArgs); + REGISTER_FST_OPERATION(GetFstInfo, Arc, GetInfoArgs); + REGISTER_FST_OPERATION(InitArcIteratorClass, Arc, + InitArcIteratorClassArgs); + REGISTER_FST_OPERATION(InitEncodeMapperClass, Arc, + InitEncodeMapperClassArgs); + REGISTER_FST_OPERATION(InitMutableArcIteratorClass, Arc, + InitMutableArcIteratorClassArgs); + REGISTER_FST_OPERATION(InitStateIteratorClass, Arc, + InitStateIteratorClassArgs); + } + + void RegisterBatch2() { + REGISTER_FST_OPERATION(Intersect, Arc, IntersectArgs); + REGISTER_FST_OPERATION(Invert, Arc, MutableFstClass); + REGISTER_FST_OPERATION(Map, Arc, MapArgs); + REGISTER_FST_OPERATION(Minimize, Arc, MinimizeArgs); + REGISTER_FST_OPERATION(PrintFst, Arc, FstPrinterArgs); + REGISTER_FST_OPERATION(Project, Arc, ProjectArgs); + REGISTER_FST_OPERATION(Prune, Arc, PruneArgs1); + REGISTER_FST_OPERATION(Prune, Arc, PruneArgs2); + REGISTER_FST_OPERATION(Push, Arc, PushArgs1); + REGISTER_FST_OPERATION(Push, Arc, PushArgs2); + REGISTER_FST_OPERATION(RandEquivalent, Arc, RandEquivalentArgs); + REGISTER_FST_OPERATION(RandGen, Arc, RandGenArgs); + REGISTER_FST_OPERATION(Relabel, Arc, RelabelArgs1); + REGISTER_FST_OPERATION(Relabel, Arc, RelabelArgs2); + REGISTER_FST_OPERATION(Replace, Arc, ReplaceArgs); + REGISTER_FST_OPERATION(Reverse, Arc, ReverseArgs); + REGISTER_FST_OPERATION(Reweight, Arc, ReweightArgs); + REGISTER_FST_OPERATION(RmEpsilon, Arc, RmEpsilonArgs); + REGISTER_FST_OPERATION(ShortestDistance, Arc, ShortestDistanceArgs1); + REGISTER_FST_OPERATION(ShortestDistance, Arc, ShortestDistanceArgs2); + REGISTER_FST_OPERATION(ShortestPath, Arc, ShortestPathArgs); + REGISTER_FST_OPERATION(Synchronize, Arc, SynchronizeArgs); + REGISTER_FST_OPERATION(TopSort, Arc, TopSortArgs); + REGISTER_FST_OPERATION(Union, Arc, UnionArgs); + REGISTER_FST_OPERATION(Verify, Arc, VerifyArgs); + } +}; + +} // namespace script +} // namespace fst + +#define REGISTER_FST_OPERATIONS(Arc) \ + AllFstOperationsRegisterer register_all_fst_operations##Arc; + +#endif // FST_SCRIPT_FSTSCRIPT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/getters.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/getters.h new file mode 100644 index 0000000000..5cd727e882 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/getters.h @@ -0,0 +1,76 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Getters for converting command-line arguments into the appropriate enums +// or bitmasks, with the simplest ones defined as inline. + +#ifndef FST_SCRIPT_GETTERS_H_ +#define FST_SCRIPT_GETTERS_H_ + +#include + +#include // For ComposeFilter. +#include // For DeterminizeType. +#include // For kEncodeLabels (etc.). +#include // For EpsNormalizeType. +#include // For ProjectType. +#include // For kPushWeights (etc.). +#include // For QueueType. +#include // For ClosureType. +#include // For ArcSortType. +#include // For MapType. +#include // For RandArcSelection. + +#include + +namespace fst { +namespace script { + +bool GetArcSortType(const string &str, ArcSortType *sort_type); + +inline ClosureType GetClosureType(bool closure_plus) { + return closure_plus ? CLOSURE_PLUS : CLOSURE_STAR; +} + +bool GetComposeFilter(const string &str, ComposeFilter *compose_filter); + +bool GetDeterminizeType(const string &str, DeterminizeType *det_type); + +inline uint32 GetEncodeFlags(bool encode_labels, bool encode_weights) { + return (encode_labels ? kEncodeLabels : 0) | + (encode_weights ? kEncodeWeights : 0); +} + +inline EpsNormalizeType GetEpsNormalizeType(bool eps_norm_output) { + return eps_norm_output ? EPS_NORM_OUTPUT : EPS_NORM_INPUT; +} + +bool GetMapType(const string &str, MapType *map_type); + +inline ProjectType GetProjectType(bool project_output) { + return project_output ? PROJECT_OUTPUT : PROJECT_INPUT; +} + +inline uint32 GetPushFlags(bool push_weights, bool push_labels, + bool remove_total_weight, bool remove_common_affix) { + return ((push_weights ? kPushWeights : 0) | + (push_labels ? kPushLabels : 0) | + (remove_total_weight ? kPushRemoveTotalWeight : 0) | + (remove_common_affix ? kPushRemoveCommonAffix : 0)); +} + +bool GetQueueType(const string &str, QueueType *queue_type); + +bool GetRandArcSelection(const string &str, RandArcSelection *ras); + +bool GetReplaceLabelType(const string &str, bool epsilon_on_replace, + ReplaceLabelType *rlt); + +inline ReweightType GetReweightType(bool to_final) { + return to_final ? REWEIGHT_TO_FINAL : REWEIGHT_TO_INITIAL; +} + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_GETTERS_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/info-impl.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/info-impl.h new file mode 100644 index 0000000000..e8956498f9 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/info-impl.h @@ -0,0 +1,314 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Class to compute various information about FSTs, a helper class for +// fstinfo.cc. + +#ifndef FST_SCRIPT_INFO_IMPL_H_ +#define FST_SCRIPT_INFO_IMPL_H_ + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace fst { + +// Compute various information about FSTs, helper class for fstinfo.cc. +// WARNING: Stand-alone use of this class is not recommended, most code +// should call directly the relevant library functions: Fst::NumStates, +// Fst::NumArcs, TestProperties, etc. +class FstInfo { + public: + FstInfo() {} + + // When info_type is "short" (or "auto" and not an ExpandedFst) then only + // minimal info is computed and can be requested. + template + FstInfo(const Fst &fst, bool test_properties, + const string &arc_filter_type = "any", + const string &info_type = "auto", bool verify = true) + : fst_type_(fst.Type()), + input_symbols_(fst.InputSymbols() ? fst.InputSymbols()->Name() + : "none"), + output_symbols_(fst.OutputSymbols() ? fst.OutputSymbols()->Name() + : "none"), + nstates_(0), + narcs_(0), + start_(kNoStateId), + nfinal_(0), + nepsilons_(0), + niepsilons_(0), + noepsilons_(0), + ilabel_mult_(0.0), + olabel_mult_(0.0), + naccess_(0), + ncoaccess_(0), + nconnect_(0), + ncc_(0), + nscc_(0), + input_match_type_(MATCH_NONE), + output_match_type_(MATCH_NONE), + input_lookahead_(false), + output_lookahead_(false), + properties_(0), + arc_filter_type_(arc_filter_type), + long_info_(true), + arc_type_(Arc::Type()) { + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + if (info_type == "long") { + long_info_ = true; + } else if (info_type == "short") { + long_info_ = false; + } else if (info_type == "auto") { + long_info_ = fst.Properties(kExpanded, false); + } else { + FSTERROR() << "Bad info type: " << info_type; + return; + } + if (!long_info_) return; + // If the FST is not sane, we return. + if (verify && !Verify(fst)) { + FSTERROR() << "FstInfo: Verify: FST not well-formed"; + return; + } + start_ = fst.Start(); + properties_ = fst.Properties(kFstProperties, test_properties); + for (StateIterator> siter(fst); !siter.Done(); siter.Next()) { + ++nstates_; + const auto s = siter.Value(); + if (fst.Final(s) != Weight::Zero()) ++nfinal_; + std::map ilabel_count; + std::map olabel_count; + for (ArcIterator> aiter(fst, s); !aiter.Done(); aiter.Next()) { + const auto &arc = aiter.Value(); + ++narcs_; + if (arc.ilabel == 0 && arc.olabel == 0) ++nepsilons_; + if (arc.ilabel == 0) ++niepsilons_; + if (arc.olabel == 0) ++noepsilons_; + ++ilabel_count[arc.ilabel]; + ++olabel_count[arc.olabel]; + } + for (auto it = ilabel_count.begin(); it != ilabel_count.end(); ++it) { + ilabel_mult_ += it->second * it->second; + } + for (auto it = olabel_count.begin(); it != olabel_count.end(); ++it) { + olabel_mult_ += it->second * it->second; + } + } + if (narcs_ > 0) { + ilabel_mult_ /= narcs_; + olabel_mult_ /= narcs_; + } + { + std::vector cc; + CcVisitor cc_visitor(&cc); + FifoQueue fifo_queue; + if (arc_filter_type == "any") { + Visit(fst, &cc_visitor, &fifo_queue); + } else if (arc_filter_type == "epsilon") { + Visit(fst, &cc_visitor, &fifo_queue, EpsilonArcFilter()); + } else if (arc_filter_type == "iepsilon") { + Visit(fst, &cc_visitor, &fifo_queue, InputEpsilonArcFilter()); + } else if (arc_filter_type == "oepsilon") { + Visit(fst, &cc_visitor, &fifo_queue, OutputEpsilonArcFilter()); + } else { + FSTERROR() << "Bad arc filter type: " << arc_filter_type; + return; + } + for (StateId s = 0; s < cc.size(); ++s) { + if (cc[s] >= ncc_) ncc_ = cc[s] + 1; + } + } + { + std::vector scc; + std::vector access, coaccess; + uint64 props = 0; + SccVisitor scc_visitor(&scc, &access, &coaccess, &props); + if (arc_filter_type == "any") { + DfsVisit(fst, &scc_visitor); + } else if (arc_filter_type == "epsilon") { + DfsVisit(fst, &scc_visitor, EpsilonArcFilter()); + } else if (arc_filter_type == "iepsilon") { + DfsVisit(fst, &scc_visitor, InputEpsilonArcFilter()); + } else if (arc_filter_type == "oepsilon") { + DfsVisit(fst, &scc_visitor, OutputEpsilonArcFilter()); + } else { + FSTERROR() << "Bad arc filter type: " << arc_filter_type; + return; + } + for (StateId s = 0; s < scc.size(); ++s) { + if (access[s]) ++naccess_; + if (coaccess[s]) ++ncoaccess_; + if (access[s] && coaccess[s]) ++nconnect_; + if (scc[s] >= nscc_) nscc_ = scc[s] + 1; + } + } + LookAheadMatcher> imatcher(fst, MATCH_INPUT); + input_match_type_ = imatcher.Type(test_properties); + input_lookahead_ = imatcher.Flags() & kInputLookAheadMatcher; + LookAheadMatcher> omatcher(fst, MATCH_OUTPUT); + output_match_type_ = omatcher.Type(test_properties); + output_lookahead_ = omatcher.Flags() & kOutputLookAheadMatcher; + } + + // Short info. + + const string &FstType() const { return fst_type_; } + + const string &ArcType() const { return arc_type_; } + + const string &InputSymbols() const { return input_symbols_; } + + const string &OutputSymbols() const { return output_symbols_; } + + bool LongInfo() const { return long_info_; } + + const string &ArcFilterType() const { return arc_filter_type_; } + + // Long info. + + MatchType InputMatchType() const { + CheckLong(); + return input_match_type_; + } + + MatchType OutputMatchType() const { + CheckLong(); + return output_match_type_; + } + + bool InputLookAhead() const { + CheckLong(); + return input_lookahead_; + } + + bool OutputLookAhead() const { + CheckLong(); + return output_lookahead_; + } + + int64 NumStates() const { + CheckLong(); + return nstates_; + } + + size_t NumArcs() const { + CheckLong(); + return narcs_; + } + + int64 Start() const { + CheckLong(); + return start_; + } + + size_t NumFinal() const { + CheckLong(); + return nfinal_; + } + + size_t NumEpsilons() const { + CheckLong(); + return nepsilons_; + } + + size_t NumInputEpsilons() const { + CheckLong(); + return niepsilons_; + } + + size_t NumOutputEpsilons() const { + CheckLong(); + return noepsilons_; + } + + double InputLabelMultiplicity() const { + CheckLong(); + return ilabel_mult_; + } + + double OutputLabelMultiplicity() const { + CheckLong(); + return olabel_mult_; + } + + size_t NumAccessible() const { + CheckLong(); + return naccess_; + } + + size_t NumCoAccessible() const { + CheckLong(); + return ncoaccess_; + } + + size_t NumConnected() const { + CheckLong(); + return nconnect_; + } + + size_t NumCc() const { + CheckLong(); + return ncc_; + } + + size_t NumScc() const { + CheckLong(); + return nscc_; + } + + uint64 Properties() const { + CheckLong(); + return properties_; + } + + private: + void CheckLong() const { + if (!long_info_) + FSTERROR() << "FstInfo: Method only available with long info signature"; + } + + string fst_type_; + string input_symbols_; + string output_symbols_; + int64 nstates_; + size_t narcs_; + int64 start_; + size_t nfinal_; + size_t nepsilons_; + size_t niepsilons_; + size_t noepsilons_; + double ilabel_mult_; + double olabel_mult_; + size_t naccess_; + size_t ncoaccess_; + size_t nconnect_; + size_t ncc_; + size_t nscc_; + MatchType input_match_type_; + MatchType output_match_type_; + bool input_lookahead_; + bool output_lookahead_; + uint64 properties_; + string arc_filter_type_; + bool long_info_; + string arc_type_; +}; + +void PrintFstInfoImpl(const FstInfo &fstinfo, bool pipe = false); + +} // namespace fst + +#endif // FST_SCRIPT_INFO_IMPL_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/info.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/info.h new file mode 100644 index 0000000000..039d06d85a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/info.h @@ -0,0 +1,50 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_INFO_H_ +#define FST_SCRIPT_INFO_H_ + +#include +#include + +#include +#include +#include + +namespace fst { +namespace script { + +using InfoArgs = std::tuple; + +template +void PrintFstInfo(InfoArgs *args) { + const Fst &fst = *(std::get<0>(*args).GetFst()); + const FstInfo fstinfo(fst, std::get<1>(*args), std::get<2>(*args), + std::get<3>(*args), std::get<4>(*args)); + PrintFstInfoImpl(fstinfo, std::get<5>(*args)); + if (std::get<5>(*args)) fst.Write(""); +} + +void PrintFstInfo(const FstClass &f, bool test_properties, + const string &arc_filter, const string &info_type, bool pipe, + bool verify); + +using GetInfoArgs = std::tuple; + +template +void GetFstInfo(GetInfoArgs *args) { + const Fst &fst = *(std::get<0>(*args).GetFst()); + *(std::get<5>(*args)) = FstInfo(fst, std::get<1>(*args), std::get<2>(*args), + std::get<3>(*args), std::get<4>(*args)); +} + +void GetFstInfo(const FstClass &fst, bool test_properties, + const string &arc_filter, const string &info_type, bool verify, + FstInfo *info); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_INFO_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/intersect.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/intersect.h new file mode 100644 index 0000000000..229bd56f5d --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/intersect.h @@ -0,0 +1,35 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_INTERSECT_H_ +#define FST_SCRIPT_INTERSECT_H_ + +#include + +#include +#include +#include + +namespace fst { +namespace script { + +using IntersectArgs = std::tuple; + +template +void Intersect(IntersectArgs *args) { + const Fst &ifst1 = *(std::get<0>(*args).GetFst()); + const Fst &ifst2 = *(std::get<1>(*args).GetFst()); + MutableFst *ofst = std::get<2>(*args)->GetMutableFst(); + const auto &opts = std::get<3>(*args); + Intersect(ifst1, ifst2, ofst, opts); +} + +void Intersect(const FstClass &ifst, const FstClass &ifst2, + MutableFstClass *ofst, + const ComposeOptions &opts = ComposeOptions()); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_INTERSECT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/invert.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/invert.h new file mode 100644 index 0000000000..5bc31317a8 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/invert.h @@ -0,0 +1,23 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_INVERT_H_ +#define FST_SCRIPT_INVERT_H_ + +#include +#include + +namespace fst { +namespace script { + +template +void Invert(MutableFstClass *fst) { + Invert(fst->GetMutableFst()); +} + +void Invert(MutableFstClass *fst); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_INVERT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/isomorphic.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/isomorphic.h new file mode 100644 index 0000000000..94ea77f9aa --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/isomorphic.h @@ -0,0 +1,34 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_ISOMORPHIC_H_ +#define FST_SCRIPT_ISOMORPHIC_H_ + +#include + +#include +#include +#include + +namespace fst { +namespace script { + +using IsomorphicInnerArgs = std::tuple; + +using IsomorphicArgs = WithReturnValue; + +template +void Isomorphic(IsomorphicArgs *args) { + const Fst &fst1 = *(std::get<0>(args->args).GetFst()); + const Fst &fst2 = *(std::get<1>(args->args).GetFst()); + args->retval = Isomorphic(fst1, fst2, std::get<2>(args->args)); +} + +bool Isomorphic(const FstClass &fst1, const FstClass &fst2, + float delta = kDelta); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_ISOMORPHIC_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/map.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/map.h new file mode 100644 index 0000000000..158d98aaf8 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/map.h @@ -0,0 +1,158 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_MAP_H_ +#define FST_SCRIPT_MAP_H_ + +#include +#include + +#include +#include +#include +#include +#include + +namespace fst { +namespace script { + +template +Fst *ArcMap(const Fst &fst, + const M &mapper) { + using ToArc = typename M::ToArc; + auto *ofst = new VectorFst; + ArcMap(fst, ofst, mapper); + return ofst; +} + +template +Fst *StateMap(const Fst &fst, + const M &mapper) { + using ToArc = typename M::ToArc; + auto *ofst = new VectorFst; + StateMap(fst, ofst, mapper); + return ofst; +} + +enum MapType { + ARC_SUM_MAPPER, + ARC_UNIQUE_MAPPER, + IDENTITY_MAPPER, + INPUT_EPSILON_MAPPER, + INVERT_MAPPER, + OUTPUT_EPSILON_MAPPER, + PLUS_MAPPER, + POWER_MAPPER, + QUANTIZE_MAPPER, + RMWEIGHT_MAPPER, + SUPERFINAL_MAPPER, + TIMES_MAPPER, + TO_LOG_MAPPER, + TO_LOG64_MAPPER, + TO_STD_MAPPER +}; + +using MapInnerArgs = + std::tuple; + +using MapArgs = WithReturnValue; + +template +void Map(MapArgs *args) { + using Weight = typename Arc::Weight; + const Fst &ifst = *(std::get<0>(args->args).GetFst()); + const auto map_type = std::get<1>(args->args); + switch (map_type) { + case ARC_SUM_MAPPER: { + std::unique_ptr> ofst(StateMap(ifst, ArcSumMapper(ifst))); + args->retval = new FstClass(*ofst); + return; + } + case ARC_UNIQUE_MAPPER: { + std::unique_ptr> ofst( + StateMap(ifst, ArcUniqueMapper(ifst))); + args->retval = new FstClass(*ofst); + return; + } + case IDENTITY_MAPPER: { + std::unique_ptr> ofst(ArcMap(ifst, IdentityArcMapper())); + args->retval = new FstClass(*ofst); + return; + } + case INPUT_EPSILON_MAPPER: { + std::unique_ptr> ofst(ArcMap(ifst, InputEpsilonMapper())); + args->retval = new FstClass(*ofst); + return; + } + case INVERT_MAPPER: { + std::unique_ptr> ofst(ArcMap(ifst, InvertWeightMapper())); + args->retval = new FstClass(*ofst); + return; + } + case OUTPUT_EPSILON_MAPPER: { + std::unique_ptr> ofst(ArcMap(ifst, OutputEpsilonMapper())); + args->retval = new FstClass(*ofst); + return; + } + case PLUS_MAPPER: { + const auto weight = *(std::get<4>(args->args).GetWeight()); + std::unique_ptr> ofst(ArcMap(ifst, PlusMapper(weight))); + args->retval = new FstClass(*ofst); + return; + } + case POWER_MAPPER: { + const auto power = std::get<3>(args->args); + std::unique_ptr> ofst(ArcMap(ifst, PowerMapper(power))); + args->retval = new FstClass(*ofst); + return; + } + case QUANTIZE_MAPPER: { + const auto delta = std::get<2>(args->args); + std::unique_ptr> ofst(ArcMap(ifst, QuantizeMapper(delta))); + args->retval = new FstClass(*ofst); + return; + } + case RMWEIGHT_MAPPER: { + std::unique_ptr> ofst(ArcMap(ifst, RmWeightMapper())); + args->retval = new FstClass(*ofst); + return; + } + case SUPERFINAL_MAPPER: { + std::unique_ptr> ofst(ArcMap(ifst, SuperFinalMapper())); + args->retval = new FstClass(*ofst); + return; + } + case TIMES_MAPPER: { + const auto weight = *(std::get<4>(args->args).GetWeight()); + std::unique_ptr> ofst(ArcMap(ifst, TimesMapper(weight))); + args->retval = new FstClass(*ofst); + return; + } + case TO_LOG_MAPPER: { + std::unique_ptr> ofst( + ArcMap(ifst, WeightConvertMapper())); + args->retval = new FstClass(*ofst); + return; + } + case TO_LOG64_MAPPER: { + std::unique_ptr> ofst( + ArcMap(ifst, WeightConvertMapper())); + args->retval = new FstClass(*ofst); + return; + } + case TO_STD_MAPPER: { + std::unique_ptr> ofst( + ArcMap(ifst, WeightConvertMapper())); + args->retval = new FstClass(*ofst); + return; + } + } +} + +FstClass *Map(const FstClass &ifst, MapType map_type, float delta, double power, + const WeightClass &weight); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_MAP_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/minimize.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/minimize.h new file mode 100644 index 0000000000..773e8ef136 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/minimize.h @@ -0,0 +1,33 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_MINIMIZE_H_ +#define FST_SCRIPT_MINIMIZE_H_ + +#include + +#include +#include + +namespace fst { +namespace script { + +using MinimizeArgs = std::tuple; + +template +void Minimize(MinimizeArgs *args) { + MutableFst *ofst1 = std::get<0>(*args)->GetMutableFst(); + MutableFst *ofst2 = (std::get<1>(*args) ? + std::get<1>(*args)->GetMutableFst() : + nullptr); + Minimize(ofst1, ofst2, std::get<2>(*args), std::get<3>(*args)); +} + +void Minimize(MutableFstClass *ofst1, MutableFstClass *ofst2 = nullptr, + float delta = kShortestDelta, bool allow_nondet = false); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_MINIMIZE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/print-impl.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/print-impl.h new file mode 100644 index 0000000000..539c6d8f45 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/print-impl.h @@ -0,0 +1,132 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Stand-alone class to print out binary FSTs in the AT&T format, a helper +// class for fstprint.cc. + +#ifndef FST_SCRIPT_PRINT_IMPL_H_ +#define FST_SCRIPT_PRINT_IMPL_H_ + +#include +#include +#include + +#include +#include + +DECLARE_string(fst_field_separator); + +namespace fst { + +// Print a binary FST in textual format (helper class for fstprint.cc). +// WARNING: Stand-alone use of this class not recommended, most code should +// read/write using the binary format which is much more efficient. +template +class FstPrinter { + public: + using StateId = typename Arc::StateId; + using Label = typename Arc::Label; + using Weight = typename Arc::Weight; + + FstPrinter(const Fst &fst, const SymbolTable *isyms, + const SymbolTable *osyms, const SymbolTable *ssyms, bool accep, + bool show_weight_one, const string &field_separator, + const string &missing_symbol = "") + : fst_(fst), + isyms_(isyms), + osyms_(osyms), + ssyms_(ssyms), + accep_(accep && fst.Properties(kAcceptor, true)), + ostrm_(nullptr), + show_weight_one_(show_weight_one), + sep_(field_separator), + missing_symbol_(missing_symbol) {} + + // Prints FST to an output stream. + void Print(std::ostream *ostrm, const string &dest) { + ostrm_ = ostrm; + dest_ = dest; + const auto start = fst_.Start(); + if (start == kNoStateId) return; + // Initial state first. + PrintState(start); + for (StateIterator> siter(fst_); !siter.Done(); siter.Next()) { + const auto s = siter.Value(); + if (s != start) PrintState(s); + } + } + + private: + void PrintId(StateId id, const SymbolTable *syms, const char *name) const { + if (syms) { + string symbol = syms->Find(id); + if (symbol.empty()) { + if (missing_symbol_.empty()) { + FSTERROR() << "FstPrinter: Integer " << id + << " is not mapped to any textual symbol" + << ", symbol table = " << syms->Name() + << ", destination = " << dest_; + symbol = "?"; + } else { + symbol = missing_symbol_; + } + } + *ostrm_ << symbol; + } else { + *ostrm_ << id; + } + } + + void PrintStateId(StateId s) const { PrintId(s, ssyms_, "state ID"); } + + void PrintILabel(Label l) const { PrintId(l, isyms_, "arc input label"); } + + void PrintOLabel(Label l) const { PrintId(l, osyms_, "arc output label"); } + + void PrintState(StateId s) const { + bool output = false; + for (ArcIterator> aiter(fst_, s); !aiter.Done(); aiter.Next()) { + const auto &arc = aiter.Value(); + PrintStateId(s); + *ostrm_ << sep_; + PrintStateId(arc.nextstate); + *ostrm_ << sep_; + PrintILabel(arc.ilabel); + if (!accep_) { + *ostrm_ << sep_; + PrintOLabel(arc.olabel); + } + if (show_weight_one_ || arc.weight != Weight::One()) + *ostrm_ << sep_ << arc.weight; + *ostrm_ << "\n"; + output = true; + } + const auto weight = fst_.Final(s); + if (weight != Weight::Zero() || !output) { + PrintStateId(s); + if (show_weight_one_ || weight != Weight::One()) { + *ostrm_ << sep_ << weight; + } + *ostrm_ << "\n"; + } + } + + const Fst &fst_; + const SymbolTable *isyms_; // ilabel symbol table. + const SymbolTable *osyms_; // olabel symbol table. + const SymbolTable *ssyms_; // slabel symbol table. + bool accep_; // Print as acceptor when possible? + std::ostream *ostrm_; // Text FST destination. + string dest_; // Text FST destination name. + bool show_weight_one_; // Print weights equal to Weight::One()? + string sep_; // Separator character between fields. + string missing_symbol_; // Symbol to print when lookup fails (default + // "" means raise error). + // + FstPrinter(const FstPrinter &) = delete; + FstPrinter &operator=(const FstPrinter &) = delete; +}; + +} // namespace fst + +#endif // FST_SCRIPT_PRINT_IMPL_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/print.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/print.h new file mode 100644 index 0000000000..687606b383 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/print.h @@ -0,0 +1,79 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_PRINT_H_ +#define FST_SCRIPT_PRINT_H_ + +#include + +#include +#include +#include + +DECLARE_string(fst_field_separator); + +namespace fst { +namespace script { + +// Note: it is safe to pass these strings as references because +// this struct is only used to pass them deeper in the call graph. +// Be sure you understand why this is so before using this struct +// for anything else! +struct FstPrinterArgs { + const FstClass &fst; + const SymbolTable *isyms; + const SymbolTable *osyms; + const SymbolTable *ssyms; + const bool accept; + const bool show_weight_one; + std::ostream *ostrm; + const string &dest; + const string &sep; // NOLINT + const string &missing_symbol; + + FstPrinterArgs(const FstClass &fst, const SymbolTable *isyms, + const SymbolTable *osyms, const SymbolTable *ssyms, + bool accept, bool show_weight_one, std::ostream *ostrm, + const string &dest, const string &sep, + const string &missing_sym = "") + : fst(fst), + isyms(isyms), + osyms(osyms), + ssyms(ssyms), + accept(accept), + show_weight_one(show_weight_one), + ostrm(ostrm), + dest(dest), + sep(sep), + missing_symbol(missing_sym) {} +}; + +template +void PrintFst(FstPrinterArgs *args) { + const Fst &fst = *(args->fst.GetFst()); + FstPrinter fstprinter(fst, args->isyms, args->osyms, args->ssyms, + args->accept, args->show_weight_one, args->sep, + args->missing_symbol); + fstprinter.Print(args->ostrm, args->dest); +} + +void PrintFst(const FstClass &fst, std::ostream &ostrm, const string &dest, + const SymbolTable *isyms, const SymbolTable *osyms, + const SymbolTable *ssyms, bool accept, bool show_weight_one, + const string &missing_sym = ""); + +// The same, but with more sensible defaults. +template +void PrintFst(const Fst &fst, std::ostream &ostrm, const string &dest = "", + const SymbolTable *isyms = nullptr, + const SymbolTable *osyms = nullptr, + const SymbolTable *ssyms = nullptr) { + const string sep = FLAGS_fst_field_separator.substr(0, 1); + FstPrinter fstprinter(fst, isyms, osyms, ssyms, true, true, sep); + fstprinter.Print(&ostrm, dest); +} + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_PRINT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/project.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/project.h new file mode 100644 index 0000000000..13edeb1d03 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/project.h @@ -0,0 +1,28 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_PROJECT_H_ +#define FST_SCRIPT_PROJECT_H_ + +#include + +#include +#include + +namespace fst { +namespace script { + +using ProjectArgs = std::pair; + +template +void Project(ProjectArgs *args) { + MutableFst *fst = std::get<0>(*args)->GetMutableFst(); + Project(fst, std::get<1>(*args)); +} + +void Project(MutableFstClass *fst, ProjectType project_type); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_PROJECT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/prune.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/prune.h new file mode 100644 index 0000000000..ed10b540c3 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/prune.h @@ -0,0 +1,51 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_PRUNE_H_ +#define FST_SCRIPT_PRUNE_H_ + +#include +#include + +#include +#include +#include + +namespace fst { +namespace script { + +using PruneArgs1 = std::tuple; + +template +void Prune(PruneArgs1 *args) { + using Weight = typename Arc::Weight; + const Fst &ifst = *(std::get<0>(*args).GetFst()); + MutableFst *ofst = std::get<1>(*args)->GetMutableFst(); + const auto weight_threshold = *(std::get<2>(*args).GetWeight()); + Prune(ifst, ofst, weight_threshold, std::get<3>(*args), std::get<4>(*args)); +} + +using PruneArgs2 = std::tuple; + +template +void Prune(PruneArgs2 *args) { + using Weight = typename Arc::Weight; + MutableFst *fst = std::get<0>(*args)->GetMutableFst(); + const auto weight_threshold = *(std::get<1>(*args).GetWeight()); + Prune(fst, weight_threshold, std::get<2>(*args), std::get<3>(*args)); +} + +void Prune(const FstClass &ifst, MutableFstClass *ofst, + const WeightClass &weight_threshold, + int64 state_threshold = kNoStateId, + float delta = kDelta); + +void Prune(MutableFstClass *fst, const WeightClass &weight_threshold, + int64 state_threshold = kNoStateId, float delta = kDelta); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_PRUNE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/push.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/push.h new file mode 100644 index 0000000000..018cd8f83c --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/push.h @@ -0,0 +1,53 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_PUSH_H_ +#define FST_SCRIPT_PUSH_H_ + +#include + +#include +#include + +namespace fst { +namespace script { + +using PushArgs1 = std::tuple; + +template +void Push(PushArgs1 *args) { + MutableFst *fst = std::get<0>(*args)->GetMutableFst(); + Push(fst, std::get<1>(*args), std::get<2>(*args), std::get<3>(*args)); +} + +using PushArgs2 = std::tuple; + +template +void Push(PushArgs2 *args) { + const Fst &ifst = *(std::get<0>(*args).GetFst()); + MutableFst *ofst = std::get<1>(*args)->GetMutableFst(); + switch (std::get<3>(*args)) { + case REWEIGHT_TO_FINAL: { + Push(ifst, ofst, std::get<2>(*args), + std::get<4>(*args)); + return; + } + case REWEIGHT_TO_INITIAL: { + Push(ifst, ofst, std::get<2>(*args), + std::get<4>(*args)); + return; + } + } +} + +void Push(MutableFstClass *fst, ReweightType rew_type, float delta = kDelta, + bool remove_total_weight = false); + +void Push(const FstClass &ifst, MutableFstClass *ofst, uint32 flags, + ReweightType rew_type, float delta = kDelta); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_PUSH_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/randequivalent.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/randequivalent.h new file mode 100644 index 0000000000..945f8a0616 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/randequivalent.h @@ -0,0 +1,67 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_RANDEQUIVALENT_H_ +#define FST_SCRIPT_RANDEQUIVALENT_H_ + +#include +#include + +#include + +#include +#include +#include +#include + +namespace fst { +namespace script { + +using RandEquivalentInnerArgs = std::tuple &>; + +using RandEquivalentArgs = WithReturnValue; + +template +void RandEquivalent(RandEquivalentArgs *args) { + const Fst &fst1 = *(std::get<0>(args->args).GetFst()); + const Fst &fst2 = *(std::get<1>(args->args).GetFst()); + const auto seed = std::get<4>(args->args); + const auto &opts = std::get<5>(args->args); + switch (opts.selector) { + case UNIFORM_ARC_SELECTOR: { + const UniformArcSelector selector(seed); + const RandGenOptions> ropts(selector, + opts.max_length); + args->retval = RandEquivalent(fst1, fst2, std::get<2>(args->args), + std::get<3>(args->args), ropts); + return; + } + case FAST_LOG_PROB_ARC_SELECTOR: { + const FastLogProbArcSelector selector(seed); + const RandGenOptions> ropts(selector, + opts.max_length); + args->retval = RandEquivalent(fst1, fst2, std::get<2>(args->args), + std::get<3>(args->args), ropts); + return; + } + case LOG_PROB_ARC_SELECTOR: { + const LogProbArcSelector selector(seed); + const RandGenOptions> ropts(selector, + opts.max_length); + args->retval = RandEquivalent(fst1, fst2, std::get<2>(args->args), + std::get<3>(args->args), ropts); + return; + } + } +} + +bool RandEquivalent(const FstClass &fst1, const FstClass &fst2, int32 npath = 1, + float delta = kDelta, time_t seed = time(nullptr), + const RandGenOptions &opts = + RandGenOptions(UNIFORM_ARC_SELECTOR)); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_RANDEQUIVALENT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/randgen.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/randgen.h new file mode 100644 index 0000000000..5ce79d01b8 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/randgen.h @@ -0,0 +1,63 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_RANDGEN_H_ +#define FST_SCRIPT_RANDGEN_H_ + +#include + +#include + +#include +#include +#include + +namespace fst { +namespace script { + +using RandGenArgs = std::tuple &>; + +template +void RandGen(RandGenArgs *args) { + const Fst &ifst = *(std::get<0>(*args).GetFst()); + MutableFst *ofst = std::get<1>(*args)->GetMutableFst(); + const time_t seed = std::get<2>(*args); + const auto &opts = std::get<3>(*args); + switch (opts.selector) { + case UNIFORM_ARC_SELECTOR: { + const UniformArcSelector selector(seed); + const RandGenOptions> ropts( + selector, opts.max_length, opts.npath, opts.weighted, + opts.remove_total_weight); + RandGen(ifst, ofst, ropts); + return; + } + case FAST_LOG_PROB_ARC_SELECTOR: { + const FastLogProbArcSelector selector(seed); + const RandGenOptions> ropts( + selector, opts.max_length, opts.npath, opts.weighted, + opts.remove_total_weight); + RandGen(ifst, ofst, ropts); + return; + } + case LOG_PROB_ARC_SELECTOR: { + const LogProbArcSelector selector(seed); + const RandGenOptions> ropts( + selector, opts.max_length, opts.npath, opts.weighted, + opts.remove_total_weight); + RandGen(ifst, ofst, ropts); + return; + } + } +} + +void RandGen(const FstClass &ifst, MutableFstClass *ofst, + time_t seed = time(nullptr), + const RandGenOptions &opts = + RandGenOptions(UNIFORM_ARC_SELECTOR)); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_RANDGEN_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/register.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/register.h new file mode 100644 index 0000000000..1be2cde7db --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/register.h @@ -0,0 +1,114 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_REGISTER_H_ +#define FST_SCRIPT_REGISTER_H_ + +#include +#include + +#include +#include +#include + +// Holds methods and classes responsible for maintaining +// the register for FstClass arc types. + +namespace fst { +namespace script { + +// Registers for reading and converting various kinds of FST classes. + +// This class definition is to avoid a nested class definition inside the +// IORegistration struct. + +template +struct FstClassRegEntry { + Reader reader; + Creator creator; + Converter converter; + + FstClassRegEntry(Reader r, Creator cr, Converter co) + : reader(r), creator(cr), converter(co) {} + + FstClassRegEntry() + : reader(NullReader), creator(NullCreator), converter(NullConverter) {} + + // Null-returning reader, creator, and converter, used when registry lookup + // fails. + + template + static FstClassType *NullReader(std::istream &strm, + const FstReadOptions &opts) { + return nullptr; + } + + static FstClassImplBase *NullCreator() { return nullptr; } + + static FstClassImplBase *NullConverter(const FstClass &other) { + return nullptr; + } +}; + +template +class FstClassIORegister + : public GenericRegister, + FstClassIORegister> { + public: + Reader GetReader(const string &arc_type) const { + return this->GetEntry(arc_type).reader; + } + + Creator GetCreator(const string &arc_type) const { + return this->GetEntry(arc_type).creator; + } + + Converter GetConverter(const string &arc_type) const { + return this->GetEntry(arc_type).converter; + } + + protected: + string ConvertKeyToSoFilename(const string &key) const final { + string legal_type(key); + ConvertToLegalCSymbol(&legal_type); + return legal_type + "-arc.so"; + } +}; + +// Struct containing everything needed to register a particular type +// of FST class (e.g., a plain FstClass, or a MutableFstClass, etc.). +template +struct IORegistration { + using Reader = FstClassType *(*)(std::istream &stream, + const FstReadOptions &opts); + + using Creator = FstClassImplBase *(*)(); + + using Converter = FstClassImplBase *(*)(const FstClass &other); + + using Entry = FstClassRegEntry; + + // FST class Register. + using Register = FstClassIORegister; + + // FST class Register-er. + using Registerer = + GenericRegisterer>; +}; + +#define REGISTER_FST_CLASS(Class, Arc) \ + static IORegistration::Registerer Class##_##Arc##_registerer( \ + Arc::Type(), \ + IORegistration::Entry(Class::Read, Class::Create, \ + Class::Convert)) + +#define REGISTER_FST_CLASSES(Arc) \ + REGISTER_FST_CLASS(FstClass, Arc); \ + REGISTER_FST_CLASS(MutableFstClass, Arc); \ + REGISTER_FST_CLASS(VectorFstClass, Arc); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_REGISTER_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/relabel.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/relabel.h new file mode 100644 index 0000000000..74443490aa --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/relabel.h @@ -0,0 +1,64 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_RELABEL_H_ +#define FST_SCRIPT_RELABEL_H_ + +#include +#include +#include +#include + +#include +#include + +namespace fst { +namespace script { + +using RelabelArgs1 = std::tuple; + +template +void Relabel(RelabelArgs1 *args) { + MutableFst *ofst = std::get<0>(*args)->GetMutableFst(); + Relabel(ofst, std::get<1>(*args), std::get<2>(*args), std::get<3>(*args), + std::get<4>(*args), std::get<5>(*args), std::get<6>(*args), + std::get<7>(*args), std::get<8>(*args)); +} + +using LabelPair = std::pair; + +using RelabelArgs2 = std::tuple &, + const std::vector &>; + +template +void Relabel(RelabelArgs2 *args) { + MutableFst *ofst = std::get<0>(*args)->GetMutableFst(); + using LabelPair = std::pair; + // In case the MutableFstClass::Label is not the same as Arc::Label, + // make a copy. + std::vector typed_ipairs(std::get<1>(*args).size()); + std::copy(std::get<1>(*args).begin(), std::get<1>(*args).end(), + typed_ipairs.begin()); + std::vector typed_opairs(std::get<2>(*args).size()); + std::copy(std::get<2>(*args).begin(), std::get<2>(*args).end(), + typed_opairs.begin()); + Relabel(ofst, typed_ipairs, typed_opairs); +} + +void Relabel(MutableFstClass *ofst, + const SymbolTable *old_isymbols, const SymbolTable *new_isymbols, + const string &unknown_isymbol, bool attach_new_isymbols, + const SymbolTable *old_osymbols, const SymbolTable *new_osymbols, + const string &unknown_osymbol, bool attach_new_osymbols); + +void Relabel(MutableFstClass *ofst, const std::vector &ipairs, + const std::vector &opairs); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_RELABEL_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/replace.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/replace.h new file mode 100644 index 0000000000..926ece247a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/replace.h @@ -0,0 +1,72 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_REPLACE_H_ +#define FST_SCRIPT_REPLACE_H_ + +#include +#include +#include + +#include +#include + +namespace fst { +namespace script { + +struct ReplaceOptions { + const int64 root; // Root rule for expansion. + const ReplaceLabelType call_label_type; // How to label call arc. + const ReplaceLabelType return_label_type; // How to label return arc. + const int64 return_label; // Specifies return arc label. + + explicit ReplaceOptions(int64 root, + ReplaceLabelType call_label_type = REPLACE_LABEL_INPUT, + ReplaceLabelType return_label_type = REPLACE_LABEL_NEITHER, + int64 return_label = 0) + : root(root), + call_label_type(call_label_type), + return_label_type(return_label_type), + return_label(return_label) {} +}; + +using LabelFstClassPair = std::pair; + +using ReplaceArgs = std::tuple &, + MutableFstClass *, const ReplaceOptions &>; + +template +void Replace(ReplaceArgs *args) { + using LabelFstPair = std::pair *>; + // Now that we know the arc type, we construct a vector of + // std::pair that the real Replace will use. + const auto &untyped_pairs = std::get<0>(*args); + std::vector typed_pairs; + typed_pairs.reserve(untyped_pairs.size()); + for (const auto &untyped_pair : untyped_pairs) { + typed_pairs.emplace_back(untyped_pair.first, // Converts label. + untyped_pair.second->GetFst()); + } + MutableFst *ofst = std::get<1>(*args)->GetMutableFst(); + const auto &opts = std::get<2>(*args); + ReplaceFstOptions typed_opts(opts.root, opts.call_label_type, + opts.return_label_type, opts.return_label); + ReplaceFst rfst(typed_pairs, typed_opts); + // Checks for cyclic dependencies before attempting expansion. + if (rfst.CyclicDependencies()) { + FSTERROR() << "Replace: Cyclic dependencies detected; cannot expand"; + ofst->SetProperties(kError, kError); + return; + } + typed_opts.gc = true; // Caching options to speed up batch copy. + typed_opts.gc_limit = 0; + *ofst = rfst; +} + +void Replace(const std::vector &pairs, + MutableFstClass *ofst, const ReplaceOptions &opts); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_REPLACE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/reverse.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/reverse.h new file mode 100644 index 0000000000..badd96b52a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/reverse.h @@ -0,0 +1,30 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_REVERSE_H_ +#define FST_SCRIPT_REVERSE_H_ + +#include + +#include +#include + +namespace fst { +namespace script { + +using ReverseArgs = std::tuple; + +template +void Reverse(ReverseArgs *args) { + const Fst &ifst = *(std::get<0>(*args).GetFst()); + MutableFst *ofst = std::get<1>(*args)->GetMutableFst(); + Reverse(ifst, ofst, std::get<2>(*args)); +} + +void Reverse(const FstClass &ifst, MutableFstClass *ofst, + bool require_superinitial = true); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_REVERSE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/reweight.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/reweight.h new file mode 100644 index 0000000000..3893ad85ad --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/reweight.h @@ -0,0 +1,37 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_REWEIGHT_H_ +#define FST_SCRIPT_REWEIGHT_H_ + +#include +#include + +#include +#include +#include +#include + +namespace fst { +namespace script { + +using ReweightArgs = std::tuple &, ReweightType>; + +template +void Reweight(ReweightArgs *args) { + using Weight = typename Arc::Weight; + MutableFst *fst = std::get<0>(*args)->GetMutableFst(); + const std::vector &potentials = std::get<1>(*args); + std::vector typed_potentials; + internal::CopyWeights(potentials, &typed_potentials); + Reweight(fst, typed_potentials, std::get<2>(*args)); +} + +void Reweight(MutableFstClass *fst, const std::vector &potentials, + ReweightType reweight_type); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_REWEIGHT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/rmepsilon.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/rmepsilon.h new file mode 100644 index 0000000000..42986c856f --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/rmepsilon.h @@ -0,0 +1,109 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_RMEPSILON_H_ +#define FST_SCRIPT_RMEPSILON_H_ + +#include +#include + +#include +#include +#include +#include +#include + +namespace fst { +namespace script { + +struct RmEpsilonOptions : public ShortestDistanceOptions { + const bool connect; + const WeightClass &weight_threshold; + const int64 state_threshold; + + RmEpsilonOptions(QueueType queue_type, bool connect, + const WeightClass &weight_threshold, + int64 state_threshold = kNoStateId, float delta = kDelta) + : ShortestDistanceOptions(queue_type, EPSILON_ARC_FILTER, kNoStateId, + delta), + connect(connect), + weight_threshold(weight_threshold), + state_threshold(state_threshold) {} +}; + +namespace internal { + +// Code to implement switching on queue types. + +template +void RmEpsilon(MutableFst *fst, + std::vector *distance, + const RmEpsilonOptions &opts, Queue *queue) { + using Weight = typename Arc::Weight; + const fst::RmEpsilonOptions ropts( + queue, opts.delta, opts.connect, + *opts.weight_threshold.GetWeight(), opts.state_threshold); + RmEpsilon(fst, distance, ropts); +} + +template +void RmEpsilon(MutableFst *fst, const RmEpsilonOptions &opts) { + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + std::vector distance; + switch (opts.queue_type) { + case AUTO_QUEUE: { + AutoQueue queue(*fst, &distance, EpsilonArcFilter()); + RmEpsilon(fst, &distance, opts, &queue); + return; + } + case FIFO_QUEUE: { + FifoQueue queue; + RmEpsilon(fst, &distance, opts, &queue); + return; + } + case LIFO_QUEUE: { + LifoQueue queue; + RmEpsilon(fst, &distance, opts, &queue); + return; + } + case SHORTEST_FIRST_QUEUE: { + NaturalShortestFirstQueue queue(distance); + RmEpsilon(fst, &distance, opts, &queue); + return; + } + case STATE_ORDER_QUEUE: { + StateOrderQueue queue; + RmEpsilon(fst, &distance, opts, &queue); + return; + } + case TOP_ORDER_QUEUE: { + TopOrderQueue queue(*fst, EpsilonArcFilter()); + internal::RmEpsilon(fst, &distance, opts, &queue); + return; + } + default: { + FSTERROR() << "RmEpsilon: Unknown queue type: " << opts.queue_type; + fst->SetProperties(kError, kError); + return; + } + } +} + +} // namespace internal + +using RmEpsilonArgs = std::pair; + +template +void RmEpsilon(RmEpsilonArgs *args) { + MutableFst *fst = std::get<0>(*args)->GetMutableFst(); + const auto &opts = std::get<1>(*args); + internal::RmEpsilon(fst, opts); +} + +void RmEpsilon(MutableFstClass *fst, const RmEpsilonOptions &opts); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_RMEPSILON_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/script-impl.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/script-impl.h new file mode 100644 index 0000000000..33c2853a92 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/script-impl.h @@ -0,0 +1,211 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// This file defines the registration mechanism for new operations. +// These operations are designed to enable scripts to work with FST classes +// at a high level. +// +// If you have a new arc type and want these operations to work with FSTs +// with that arc type, see below for the registration steps +// you must take. +// +// These methods are only recommended for use in high-level scripting +// applications. Most users should use the lower-level templated versions +// corresponding to these. +// +// If you have a new arc type you'd like these operations to work with, +// use the REGISTER_FST_OPERATIONS macro defined in fstscript.h. +// +// If you have a custom operation you'd like to define, you need four +// components. In the following, assume you want to create a new operation +// with the signature +// +// void Foo(const FstClass &ifst, MutableFstClass *ofst); +// +// You need: +// +// 1) A way to bundle the args that your new Foo operation will take, as +// a single struct. The template structs in arg-packs.h provide a handy +// way to do this. In Foo's case, that might look like this: +// +// using FooArgs = std::pair; +// +// Note: this package of args is going to be passed by non-const pointer. +// +// 2) A function template that is able to perform Foo, given the args and +// arc type. Yours might look like this: +// +// template +// void Foo(FooArgs *args) { +// // Pulls out the actual, arc-templated FSTs. +// const Fst &ifst = std::get<0>(*args).GetFst(); +// MutableFst *ofst = std::get<1>(*args)->GetMutableFst(); +// // Actually perform Foo on ifst and ofst. +// } +// +// 3) a client-facing function for your operation. This would look like +// the following: +// +// void Foo(const FstClass &ifst, MutableFstClass *ofst) { +// // Check that the arc types of the FSTs match +// if (!ArcTypesMatch(ifst, *ofst, "Foo")) return; +// // package the args +// FooArgs args(ifst, ofst); +// // Finally, call the operation +// Apply>("Foo", ifst->ArcType(), &args); +// } +// +// The Apply<> function template takes care of the link between 2 and 3, +// provided you also have: +// +// 4) A registration for your new operation, on the arc types you care about. +// This can be provided easily by the REGISTER_FST_OPERATION macro in +// operations.h: +// +// REGISTER_FST_OPERATION(Foo, StdArc, FooArgs); +// REGISTER_FST_OPERATION(Foo, MyArc, FooArgs); +// // .. etc +// +// +// That's it! Now when you call Foo(const FstClass &, MutableFstClass *), +// it dispatches (in #3) via the Apply<> function to the correct +// instantiation of the template function in #2. +// + +#ifndef FST_SCRIPT_SCRIPT_IMPL_H_ +#define FST_SCRIPT_SCRIPT_IMPL_H_ + +// This file contains general-purpose templates which are used in the +// implementation of the operations. + +#include +#include + +#include +#include + +#include + +namespace fst { +namespace script { + +enum RandArcSelection { + UNIFORM_ARC_SELECTOR, + LOG_PROB_ARC_SELECTOR, + FAST_LOG_PROB_ARC_SELECTOR +}; + +// A generic register for operations with various kinds of signatures. +// Needed since every function signature requires a new registration class. +// The std::pair is understood to be the operation name and arc +// type; subclasses (or typedefs) need only provide the operation signature. + +template +class GenericOperationRegister + : public GenericRegister, OperationSignature, + GenericOperationRegister> { + public: + void RegisterOperation(const string &operation_name, const string &arc_type, + OperationSignature op) { + this->SetEntry(std::make_pair(operation_name, arc_type), op); + } + + OperationSignature GetOperation(const string &operation_name, + const string &arc_type) { + return this->GetEntry(std::make_pair(operation_name, arc_type)); + } + + protected: + string ConvertKeyToSoFilename( + const std::pair &key) const final { + // Uses the old-style FST for now. + string legal_type(key.second); // The arc type. + ConvertToLegalCSymbol(&legal_type); + return legal_type + "-arc.so"; + } +}; + +// Operation package: everything you need to register a new type of operation. +// The ArgPack should be the type that's passed into each wrapped function; +// for instance, it might be a struct containing all the args. It's always +// passed by pointer, so const members should be used to enforce constness where +// it's needed. Return values should be implemented as a member of ArgPack as +// well. + +template +struct Operation { + using ArgPack = Args; + + using OpType = void (*)(ArgPack *args); + + // The register (hash) type. + using Register = GenericOperationRegister; + + // The register-er type + using Registerer = GenericRegisterer; +}; + +// Macro for registering new types of operations. + +#define REGISTER_FST_OPERATION(Op, Arc, ArgPack) \ + static fst::script::Operation::Registerer \ + arc_dispatched_operation_##ArgPack##Op##Arc##_registerer \ + (std::make_pair(#Op, Arc::Type()), Op) + +// Template function to apply an operation by name. + +template +void Apply(const string &op_name, const string &arc_type, + typename OpReg::ArgPack *args) { + const auto op = OpReg::Register::GetRegister()->GetOperation(op_name, + arc_type); + if (!op) { + FSTERROR() << "No operation found for " << op_name << " on " + << "arc type " << arc_type; + return; + } + op(args); +} + +namespace internal { + +// Helper that logs to ERROR if the arc types of m and n don't match, +// assuming that both m and n implement .ArcType(). The op_name argument is +// used to construct the error message. +template +bool ArcTypesMatch(const M &m, const N &n, const string &op_name) { + if (m.ArcType() != n.ArcType()) { + FSTERROR() << "Arguments with non-matching arc types passed to " + << op_name << ":\t" << m.ArcType() << " and " << n.ArcType(); + return false; + } + return true; +} + +// From untyped to typed weights. +template +void CopyWeights(const std::vector &weights, + std::vector *typed_weights) { + typed_weights->clear(); + typed_weights->reserve(weights.size()); + for (const auto &weight : weights) { + typed_weights->push_back(*weight.GetWeight()); + } +} + +// From typed to untyped weights. +template +void CopyWeights(const std::vector &typed_weights, + std::vector *weights) { + weights->clear(); + weights->reserve(typed_weights.size()); + for (const auto &typed_weight : typed_weights) { + weights->emplace_back(typed_weight); + } +} + +} // namespace internal +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_SCRIPT_IMPL_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/shortest-distance.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/shortest-distance.h new file mode 100644 index 0000000000..a44a6c9b7d --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/shortest-distance.h @@ -0,0 +1,214 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_SHORTEST_DISTANCE_H_ +#define FST_SCRIPT_SHORTEST_DISTANCE_H_ + +#include +#include + +#include +#include +#include +#include +#include +#include + +namespace fst { +namespace script { + +enum ArcFilterType { + ANY_ARC_FILTER, + EPSILON_ARC_FILTER, + INPUT_EPSILON_ARC_FILTER, + OUTPUT_EPSILON_ARC_FILTER +}; + +struct ShortestDistanceOptions { + const QueueType queue_type; + const ArcFilterType arc_filter_type; + const int64 source; + const float delta; + + ShortestDistanceOptions(QueueType queue_type, ArcFilterType arc_filter_type, + int64 source, float delta) + : queue_type(queue_type), + arc_filter_type(arc_filter_type), + source(source), + delta(delta) {} +}; + +namespace internal { + +// Code to implement switching on queue and arc filter types. + +template +struct QueueConstructor { + using Weight = typename Arc::Weight; + + static Queue *Construct(const Fst &, const std::vector *) { + return new Queue(); + } +}; + +// Specializations to support queues with different constructors. + +template +struct QueueConstructor, ArcFilter> { + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + // template + static AutoQueue *Construct(const Fst &fst, + const std::vector *distance) { + return new AutoQueue(fst, distance, ArcFilter()); + } +}; + +template +struct QueueConstructor< + Arc, NaturalShortestFirstQueue, + ArcFilter> { + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + static NaturalShortestFirstQueue *Construct( + const Fst &, const std::vector *distance) { + return new NaturalShortestFirstQueue(*distance); + } +}; + +template +struct QueueConstructor, ArcFilter> { + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + static TopOrderQueue *Construct(const Fst &fst, + const std::vector *) { + return new TopOrderQueue(fst, ArcFilter()); + } +}; + +template +void ShortestDistance(const Fst &fst, + std::vector *distance, + const ShortestDistanceOptions &opts) { + std::unique_ptr queue( + QueueConstructor::Construct(fst, distance)); + const fst::ShortestDistanceOptions sopts( + queue.get(), ArcFilter(), opts.source, opts.delta); + ShortestDistance(fst, distance, sopts); +} + +template +void ShortestDistance(const Fst &fst, + std::vector *distance, + const ShortestDistanceOptions &opts) { + switch (opts.arc_filter_type) { + case ANY_ARC_FILTER: { + ShortestDistance>(fst, distance, opts); + return; + } + case EPSILON_ARC_FILTER: { + ShortestDistance>(fst, distance, opts); + return; + } + case INPUT_EPSILON_ARC_FILTER: { + ShortestDistance>(fst, distance, + opts); + return; + } + case OUTPUT_EPSILON_ARC_FILTER: { + ShortestDistance>(fst, distance, + opts); + return; + } + default: { + FSTERROR() << "ShortestDistance: Unknown arc filter type: " + << opts.arc_filter_type; + distance->clear(); + distance->resize(1, Arc::Weight::NoWeight()); + return; + } + } +} + +} // namespace internal + +using ShortestDistanceArgs1 = + std::tuple *, + const ShortestDistanceOptions &>; + +template +void ShortestDistance(ShortestDistanceArgs1 *args) { + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + const Fst &fst = *(std::get<0>(*args).GetFst()); + const auto &opts = std::get<2>(*args); + std::vector typed_distance; + switch (opts.queue_type) { + case AUTO_QUEUE: { + internal::ShortestDistance>(fst, &typed_distance, + opts); + break; + } + case FIFO_QUEUE: { + internal::ShortestDistance>(fst, &typed_distance, + opts); + break; + } + case LIFO_QUEUE: { + internal::ShortestDistance>(fst, &typed_distance, + opts); + break; + } + case SHORTEST_FIRST_QUEUE: { + internal::ShortestDistance>( + fst, &typed_distance, opts); + break; + } + case STATE_ORDER_QUEUE: { + internal::ShortestDistance>( + fst, &typed_distance, opts); + break; + } + case TOP_ORDER_QUEUE: { + internal::ShortestDistance>( + fst, &typed_distance, opts); + break; + } + default: { + FSTERROR() << "ShortestDistance: Unknown queue type: " << opts.queue_type; + typed_distance.clear(); + typed_distance.resize(1, Arc::Weight::NoWeight()); + break; + } + } + internal::CopyWeights(typed_distance, std::get<1>(*args)); +} + +using ShortestDistanceArgs2 = + std::tuple *, bool, double>; + +template +void ShortestDistance(ShortestDistanceArgs2 *args) { + using Weight = typename Arc::Weight; + const Fst &fst = *(std::get<0>(*args).GetFst()); + std::vector typed_distance; + ShortestDistance(fst, &typed_distance, std::get<2>(*args), + std::get<3>(*args)); + internal::CopyWeights(typed_distance, std::get<1>(*args)); +} + +void ShortestDistance(const FstClass &fst, std::vector *distance, + const ShortestDistanceOptions &opts); + +void ShortestDistance(const FstClass &ifst, std::vector *distance, + bool reverse = false, + double delta = fst::kShortestDelta); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_SHORTEST_DISTANCE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/shortest-path.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/shortest-path.h new file mode 100644 index 0000000000..86bc88dac6 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/shortest-path.h @@ -0,0 +1,116 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_SHORTEST_PATH_H_ +#define FST_SCRIPT_SHORTEST_PATH_H_ + +#include +#include + +#include +#include +#include +#include + +namespace fst { +namespace script { + +// Slightly simplified interface: `has_distance` and `first_path` are disabled. + +struct ShortestPathOptions : public ShortestDistanceOptions { + const int32 nshortest; + const bool unique; + const WeightClass &weight_threshold; + const int64 state_threshold; + + ShortestPathOptions(QueueType queue_type, int32 nshortest, bool unique, + float delta, const WeightClass &weight_threshold, + int64 state_threshold = kNoStateId) + : ShortestDistanceOptions(queue_type, ANY_ARC_FILTER, kNoStateId, delta), + nshortest(nshortest), + unique(unique), + weight_threshold(weight_threshold), + state_threshold(state_threshold) {} +}; + +namespace internal { + +// Code to implement switching on queue types. + +template +void ShortestPath(const Fst &ifst, MutableFst *ofst, + std::vector *distance, + const ShortestPathOptions &opts) { + using ArcFilter = AnyArcFilter; + using Weight = typename Arc::Weight; + const std::unique_ptr queue( + QueueConstructor::Construct(ifst, distance)); + const fst::ShortestPathOptions sopts( + queue.get(), ArcFilter(), opts.nshortest, opts.unique, + /* has_distance=*/false, opts.delta, /* first_path=*/false, + *opts.weight_threshold.GetWeight(), opts.state_threshold); + ShortestPath(ifst, ofst, distance, sopts); +} + +template +void ShortestPath(const Fst &ifst, MutableFst *ofst, + const ShortestPathOptions &opts) { + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + std::vector distance; + switch (opts.queue_type) { + case AUTO_QUEUE: { + ShortestPath>(ifst, ofst, &distance, opts); + return; + } + case FIFO_QUEUE: { + ShortestPath>(ifst, ofst, &distance, opts); + return; + } + case LIFO_QUEUE: { + ShortestPath>(ifst, ofst, &distance, opts); + return; + } + case SHORTEST_FIRST_QUEUE: { + ShortestPath>(ifst, ofst, + &distance, + opts); + return; + } + case STATE_ORDER_QUEUE: { + ShortestPath>(ifst, ofst, &distance, opts); + return; + } + case TOP_ORDER_QUEUE: { + ShortestPath>(ifst, ofst, &distance, opts); + return; + } + default: { + FSTERROR() << "ShortestPath: Unknown queue type: " + << opts.queue_type; + ofst->SetProperties(kError, kError); + return; + } + } +} + +} // namespace internal + +using ShortestPathArgs = std::tuple; + +template +void ShortestPath(ShortestPathArgs *args) { + const Fst &ifst = *(std::get<0>(*args).GetFst()); + MutableFst *ofst = std::get<1>(*args)->GetMutableFst(); + const ShortestPathOptions &opts = std::get<2>(*args); + internal::ShortestPath(ifst, ofst, opts); +} + +void ShortestPath(const FstClass &ifst, MutableFstClass *ofst, + const ShortestPathOptions &opts); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_SHORTEST_PATH_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/stateiterator-class.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/stateiterator-class.h new file mode 100644 index 0000000000..f6fddfe64d --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/stateiterator-class.h @@ -0,0 +1,85 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_STATEITERATOR_CLASS_H_ +#define FST_SCRIPT_STATEITERATOR_CLASS_H_ + +#include + +#include +#include + +// Scripting API support for StateIterator. + +namespace fst { +namespace script { + +// Virtual interface implemented by each concrete StateIteratorImpl. +class StateIteratorImplBase { + public: + virtual bool Done() const = 0; + virtual int64 Value() const = 0; + virtual void Next() = 0; + virtual void Reset() = 0; + virtual ~StateIteratorImplBase() {} +}; + +// Templated implementation. +template +class StateIteratorClassImpl : public StateIteratorImplBase { + public: + explicit StateIteratorClassImpl(const Fst &fst) : siter_(fst) {} + + bool Done() const final { return siter_.Done(); } + + int64 Value() const final { return siter_.Value(); } + + void Next() final { siter_.Next(); } + + void Reset() final { siter_.Reset(); } + + ~StateIteratorClassImpl() override {} + + private: + StateIterator> siter_; +}; + +class StateIteratorClass; + +using InitStateIteratorClassArgs = + std::pair; + +// Untemplated user-facing class holding a templated pimpl. +class StateIteratorClass { + public: + explicit StateIteratorClass(const FstClass &fst); + + template + explicit StateIteratorClass(const Fst &fst) + : impl_(new StateIteratorClassImpl(fst)) {} + + bool Done() const { return impl_->Done(); } + + int64 Value() const { return impl_->Value(); } + + void Next() { impl_->Next(); } + + void Reset() { impl_->Reset(); } + + template + friend void InitStateIteratorClass(InitStateIteratorClassArgs *args); + + private: + std::unique_ptr impl_; +}; + +template +void InitStateIteratorClass(InitStateIteratorClassArgs *args) { + const Fst &fst = *(std::get<0>(*args).GetFst()); + std::get<1>(*args)->impl_.reset(new StateIteratorClassImpl(fst)); +} + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_STATEITERATOR_CLASS_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/synchronize.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/synchronize.h new file mode 100644 index 0000000000..01df151a70 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/synchronize.h @@ -0,0 +1,29 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_SYNCHRONIZE_H_ +#define FST_SCRIPT_SYNCHRONIZE_H_ + +#include + +#include +#include + +namespace fst { +namespace script { + +using SynchronizeArgs = std::pair; + +template +void Synchronize(SynchronizeArgs *args) { + const Fst &ifst = *(std::get<0>(*args).GetFst()); + MutableFst *ofst = std::get<1>(*args)->GetMutableFst(); + Synchronize(ifst, ofst); +} + +void Synchronize(const FstClass &ifst, MutableFstClass *ofst); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_SYNCHRONIZE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/text-io.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/text-io.h new file mode 100644 index 0000000000..464bf885e3 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/text-io.h @@ -0,0 +1,28 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Utilities for reading and writing textual strings representing states, +// labels, and weights and files specifying label-label pairs and potentials +// (state-weight pairs). + +#ifndef FST_SCRIPT_TEXT_IO_H__ +#define FST_SCRIPT_TEXT_IO_H__ + +#include +#include + +#include + +namespace fst { +namespace script { + +bool ReadPotentials(const string &weight_type, const string &filename, + std::vector *potentials); + +bool WritePotentials(const string &filename, + const std::vector &potentials); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_TEXT_IO_H__ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/topsort.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/topsort.h new file mode 100644 index 0000000000..fb6738d70b --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/topsort.h @@ -0,0 +1,26 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_TOPSORT_H_ +#define FST_SCRIPT_TOPSORT_H_ + +#include +#include +#include + +namespace fst { +namespace script { + +using TopSortArgs = WithReturnValue; + +template +void TopSort(TopSortArgs *args) { + args->retval = TopSort(args->args->GetMutableFst()); +} + +bool TopSort(MutableFstClass *fst); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_TOPSORT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/union.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/union.h new file mode 100644 index 0000000000..9493e2b16e --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/union.h @@ -0,0 +1,29 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_UNION_H_ +#define FST_SCRIPT_UNION_H_ + +#include + +#include +#include + +namespace fst { +namespace script { + +using UnionArgs = std::pair; + +template +void Union(UnionArgs *args) { + MutableFst *fst1 = std::get<0>(*args)->GetMutableFst(); + const Fst &fst2 = *(std::get<1>(*args).GetFst()); + Union(fst1, fst2); +} + +void Union(MutableFstClass *fst1, const FstClass &fst2); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_UNION_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/verify.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/verify.h new file mode 100644 index 0000000000..52f5864196 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/verify.h @@ -0,0 +1,27 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#ifndef FST_SCRIPT_VERIFY_H_ +#define FST_SCRIPT_VERIFY_H_ + +#include +#include +#include + +namespace fst { +namespace script { + +using VerifyArgs = WithReturnValue; + +template +void Verify(VerifyArgs *args) { + const Fst &fst = *(args->args.GetFst()); + args->retval = Verify(fst); +} + +bool Verify(const FstClass &fst); + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_VERIFY_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/weight-class.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/weight-class.h new file mode 100644 index 0000000000..4e5c65fb7c --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/script/weight-class.h @@ -0,0 +1,230 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Represents a generic weight in an FST; that is, represents a specific type +// of weight underneath while hiding that type from a client. + +#ifndef FST_SCRIPT_WEIGHT_CLASS_H_ +#define FST_SCRIPT_WEIGHT_CLASS_H_ + +#include +#include +#include + +#include +#include +#include +#include + +namespace fst { +namespace script { + +class WeightImplBase { + public: + virtual WeightImplBase *Copy() const = 0; + virtual void Print(std::ostream *o) const = 0; + virtual const string &Type() const = 0; + virtual string ToString() const = 0; + virtual bool operator==(const WeightImplBase &other) const = 0; + virtual bool operator!=(const WeightImplBase &other) const = 0; + virtual WeightImplBase &PlusEq(const WeightImplBase &other) = 0; + virtual WeightImplBase &TimesEq(const WeightImplBase &other) = 0; + virtual WeightImplBase &DivideEq(const WeightImplBase &other) = 0; + virtual WeightImplBase &PowerEq(size_t n) = 0; + virtual ~WeightImplBase() {} +}; + +template +class WeightClassImpl : public WeightImplBase { + public: + explicit WeightClassImpl(const W &weight) : weight_(weight) {} + + WeightClassImpl *Copy() const final { + return new WeightClassImpl(weight_); + } + + const string &Type() const final { return W::Type(); } + + void Print(std::ostream *ostrm) const final { *ostrm << weight_; } + + string ToString() const final { + string str; + WeightToStr(weight_, &str); + return str; + } + + bool operator==(const WeightImplBase &other) const final { + const auto *typed_other = static_cast *>(&other); + return weight_ == typed_other->weight_; + } + + bool operator!=(const WeightImplBase &other) const final { + return !(*this == other); + } + + WeightClassImpl &PlusEq(const WeightImplBase &other) final { + const auto *typed_other = static_cast *>(&other); + weight_ = Plus(weight_, typed_other->weight_); + return *this; + } + + WeightClassImpl &TimesEq(const WeightImplBase &other) final { + const auto *typed_other = static_cast *>(&other); + weight_ = Times(weight_, typed_other->weight_); + return *this; + } + + WeightClassImpl &DivideEq(const WeightImplBase &other) final { + const auto *typed_other = static_cast *>(&other); + weight_ = Divide(weight_, typed_other->weight_); + return *this; + } + + WeightClassImpl &PowerEq(size_t n) final { + weight_ = Power(weight_, n); + return *this; + } + + W *GetImpl() { return &weight_; } + + private: + W weight_; +}; + + +class WeightClass { + public: + WeightClass() = default; + + template + explicit WeightClass(const W &weight) + : impl_(new WeightClassImpl(weight)) {} + + template + explicit WeightClass(const WeightClassImpl &impl) + : impl_(new WeightClassImpl(impl)) {} + + WeightClass(const string &weight_type, const string &weight_str); + + WeightClass(const WeightClass &other) + : impl_(other.impl_ ? other.impl_->Copy() : nullptr) {} + + WeightClass &operator=(const WeightClass &other) { + impl_.reset(other.impl_ ? other.impl_->Copy() : nullptr); + return *this; + } + + static constexpr const char *__ZERO__ = "__ZERO__"; // NOLINT + + static WeightClass Zero(const string &weight_type); + + static constexpr const char *__ONE__ = "__ONE__"; // NOLINT + + static WeightClass One(const string &weight_type); + + static constexpr const char *__NOWEIGHT__ = "__NOWEIGHT__"; // NOLINT + + static WeightClass NoWeight(const string &weight_type); + + template + const W *GetWeight() const { + if (W::Type() != impl_->Type()) { + return nullptr; + } else { + auto *typed_impl = static_cast *>(impl_.get()); + return typed_impl->GetImpl(); + } + } + + string ToString() const { return (impl_) ? impl_->ToString() : "none"; } + + const string &Type() const { + if (impl_) return impl_->Type(); + static const string *const no_type = new string("none"); + return *no_type; + } + + bool WeightTypesMatch(const WeightClass &other, const string &op_name) const; + + friend bool operator==(const WeightClass &lhs, const WeightClass &rhs); + + friend WeightClass Plus(const WeightClass &lhs, const WeightClass &rhs); + + friend WeightClass Times(const WeightClass &lhs, const WeightClass &rhs); + + friend WeightClass Divide(const WeightClass &lhs, const WeightClass &rhs); + + friend WeightClass Power(const WeightClass &w, size_t n); + + private: + const WeightImplBase *GetImpl() const { return impl_.get(); } + + WeightImplBase *GetImpl() { return impl_.get(); } + + std::unique_ptr impl_; + + friend std::ostream &operator<<(std::ostream &o, const WeightClass &c); +}; + +bool operator==(const WeightClass &lhs, const WeightClass &rhs); + +bool operator!=(const WeightClass &lhs, const WeightClass &rhs); + +WeightClass Plus(const WeightClass &lhs, const WeightClass &rhs); + +WeightClass Times(const WeightClass &lhs, const WeightClass &rhs); + +WeightClass Divide(const WeightClass &lhs, const WeightClass &rhs); + +WeightClass Power(const WeightClass &w, size_t n); + +std::ostream &operator<<(std::ostream &o, const WeightClass &c); + +// Registration for generic weight types. + +using StrToWeightImplBaseT = WeightImplBase *(*)(const string &str, + const string &src, + size_t nline); + +template +WeightImplBase *StrToWeightImplBase(const string &str, const string &src, + size_t nline) { + if (str == WeightClass::__ZERO__) + return new WeightClassImpl(W::Zero()); + else if (str == WeightClass::__ONE__) + return new WeightClassImpl(W::One()); + else if (str == WeightClass::__NOWEIGHT__) + return new WeightClassImpl(W::NoWeight()); + return new WeightClassImpl(StrToWeight(str, src, nline)); +} + +class WeightClassRegister : public GenericRegister { + protected: + string ConvertKeyToSoFilename(const string &key) const final { + string legal_type(key); + ConvertToLegalCSymbol(&legal_type); + return legal_type + ".so"; + } +}; + +using WeightClassRegisterer = GenericRegisterer; + +// Internal version; needs to be called by wrapper in order for macro args to +// expand. +#define REGISTER_FST_WEIGHT__(Weight, line) \ + static WeightClassRegisterer weight_registerer##_##line( \ + Weight::Type(), StrToWeightImplBase) + +// This layer is where __FILE__ and __LINE__ are expanded. +#define REGISTER_FST_WEIGHT_EXPANDER(Weight, line) \ + REGISTER_FST_WEIGHT__(Weight, line) + +// Macro for registering new weight types; clients call this. +#define REGISTER_FST_WEIGHT(Weight) \ + REGISTER_FST_WEIGHT_EXPANDER(Weight, __LINE__) + +} // namespace script +} // namespace fst + +#endif // FST_SCRIPT_WEIGHT_CLASS_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/set-weight.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/set-weight.h new file mode 100644 index 0000000000..202fa52320 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/set-weight.h @@ -0,0 +1,618 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Weights consisting of sets (of integral Labels) and +// associated semiring operation definitions using intersect +// and union. + +#ifndef FST_SET_WEIGHT_H_ +#define FST_SET_WEIGHT_H_ + +#include + +#include +#include +#include +#include + +#include +#include + + +namespace fst { + +constexpr int kSetEmpty = 0; // Label for the empty set. +constexpr int kSetUniv = -1; // Label for the universal set. +constexpr int kSetBad = -2; // Label for a non-set. +constexpr char kSetSeparator = '_'; // Label separator in sets. + +// Determines whether to use (intersect, union) or (union, intersect) +// as (+, *) for the semiring. SET_INTERSECT_UNION_RESTRICTED is a +// restricted version of (intersect, union) that requires summed +// arguments to be equal (or an error is signalled), useful for +// algorithms that require a unique labelled path weight. SET_BOOLEAN +// treats all non-Zero() elements as equivalent (with Zero() == +// UnivSet()), useful for algorithms that don't really depend on the +// detailed sets. +enum SetType { SET_INTERSECT_UNION = 0, + SET_UNION_INTERSECT = 1, + SET_INTERSECT_UNION_RESTRICT = 2, + SET_BOOLEAN = 3 }; + +template +class SetWeightIterator; + +// Set semiring of integral labels. +template +class SetWeight { + public: + using Label = Label_; + using ReverseWeight = SetWeight; + using Iterator = SetWeightIterator; + friend class SetWeightIterator; + // Allow type-converting copy and move constructors private access. + template + friend class SetWeight; + + SetWeight() {} + + // Input should be positive, sorted and unique. + template + SetWeight(const Iterator &begin, const Iterator &end) { + for (auto iter = begin; iter != end; ++iter) PushBack(*iter); + } + + // Input should be positive. (Non-positive value has + // special internal meaning w.r.t. integral constants above.) + explicit SetWeight(Label label) { PushBack(label); } + + template + explicit SetWeight(const SetWeight &w) + : first_(w.first_), rest_(w.rest_) {} + + template + explicit SetWeight(SetWeight &&w) + : first_(w.first_), rest_(std::move(w.rest_)) { w.Clear(); } + + template + SetWeight &operator=(const SetWeight &w) { + first_ = w.first_; + rest_ = w.rest_; + return *this; + } + + template + SetWeight &operator=(SetWeight &&w) { + first_ = w.first_; + rest_ = std::move(w.rest_); + w.Clear(); + return *this; + } + + static const SetWeight &Zero() { + return S == SET_UNION_INTERSECT ? EmptySet() : UnivSet(); + } + + static const SetWeight &One() { + return S == SET_UNION_INTERSECT ? UnivSet() : EmptySet(); + } + + static const SetWeight &NoWeight() { + static const auto *const no_weight = new SetWeight(Label(kSetBad)); + return *no_weight; + } + + static const string &Type() { + static const string *const type = new string( + S == SET_UNION_INTERSECT + ? "union_intersect_set" + : (S == SET_INTERSECT_UNION + ? "intersect_union_set" + : (S == SET_INTERSECT_UNION_RESTRICT + ? "restricted_set_intersect_union" + : "boolean_set"))); + return *type; + } + + bool Member() const; + + std::istream &Read(std::istream &strm); + + std::ostream &Write(std::ostream &strm) const; + + size_t Hash() const; + + SetWeight Quantize(float delta = kDelta) const { return *this; } + + ReverseWeight Reverse() const; + + static constexpr uint64 Properties() { + return kIdempotent | kLeftSemiring | kRightSemiring | kCommutative; + } + + // These operations combined with the SetWeightIterator + // provide the access and mutation of the set internal elements. + + // The empty set. + static const SetWeight &EmptySet() { + static const auto *const empty = new SetWeight(Label(kSetEmpty)); + return *empty; + } + + // The univeral set. + static const SetWeight &UnivSet() { + static const auto *const univ = new SetWeight(Label(kSetUniv)); + return *univ; + } + + // Clear existing SetWeight. + void Clear() { + first_ = kSetEmpty; + rest_.clear(); + } + + size_t Size() const { return first_ == kSetEmpty ? 0 : rest_.size() + 1; } + + Label Back() { + if (rest_.empty()) { + return first_; + } else { + return rest_.back(); + } + } + + // Caller must add in sort order and be unique (or error signalled). + // Input should also be positive. Non-positive value (for the first + // push) has special internal meaning w.r.t. integral constants above. + void PushBack(Label label) { + if (first_ == kSetEmpty) { + first_ = label; + } else { + if (label <= Back() || label <= 0) { + FSTERROR() << "SetWeight: labels must be positive, added" + << " in sort order and be unique."; + rest_.push_back(Label(kSetBad)); + } + rest_.push_back(label); + } + } + + private: + Label first_ = kSetEmpty; // First label in set (kSetEmpty if empty). + std::list &fst); +// +// // Required copy constructor that allows updating FST argument; +// // pass only if relevant and changed. +// StateMapper(const StateMapper &mapper, const Fst *fst = 0); +// +// // Specifies initial state of result. +// B::StateId Start() const; +// // Specifies state's final weight in result. +// B::Weight Final(B::StateId state) const; +// +// // These methods iterate through a state's arcs in result. +// +// // Specifies state to iterate over. +// void SetState(B::StateId state); +// +// // End of arcs? +// bool Done() const; +// +// // Current arc. +// const B &Value() const; +// +// // Advances to next arc (when !Done) +// void Next(); +// +// // Specifies input symbol table action the mapper requires (see above). +// MapSymbolsAction InputSymbolsAction() const; +// +// // Specifies output symbol table action the mapper requires (see above). +// MapSymbolsAction OutputSymbolsAction() const; +// +// // This specifies the known properties of an FST mapped by this +// // mapper. It takes as argument the input FST's known properties. +// uint64 Properties(uint64 props) const; +// }; +// +// We include a various state map versions below. One dimension of variation is +// whether the mapping mutates its input, writes to a new result FST, or is an +// on-the-fly Fst. Another dimension is how we pass the mapper. We allow passing +// the mapper by pointer for cases that we need to change the state of the +// user's mapper. We also include map versions that pass the mapper by value or +// const reference when this suffices. + +// Maps an arc type A using a mapper function object C, passed by pointer. This +// version modifies the input FST. +template +void StateMap(MutableFst *fst, C *mapper) { + if (mapper->InputSymbolsAction() == MAP_CLEAR_SYMBOLS) { + fst->SetInputSymbols(nullptr); + } + if (mapper->OutputSymbolsAction() == MAP_CLEAR_SYMBOLS) { + fst->SetOutputSymbols(nullptr); + } + if (fst->Start() == kNoStateId) return; + const auto props = fst->Properties(kFstProperties, false); + fst->SetStart(mapper->Start()); + for (StateIterator> siter(*fst); !siter.Done(); siter.Next()) { + const auto state = siter.Value(); + mapper->SetState(state); + fst->DeleteArcs(state); + for (; !mapper->Done(); mapper->Next()) { + fst->AddArc(state, mapper->Value()); + } + fst->SetFinal(state, mapper->Final(state)); + } + fst->SetProperties(mapper->Properties(props), kFstProperties); +} + +// Maps an arc type A using a mapper function object C, passed by value. +// This version modifies the input FST. +template +void StateMap(MutableFst *fst, C mapper) { + StateMap(fst, &mapper); +} + +// Maps an arc type A to an arc type B using mapper functor C, passed by +// pointer. This version writes to an output FST. +template +void StateMap(const Fst &ifst, MutableFst *ofst, C *mapper) { + ofst->DeleteStates(); + if (mapper->InputSymbolsAction() == MAP_COPY_SYMBOLS) { + ofst->SetInputSymbols(ifst.InputSymbols()); + } else if (mapper->InputSymbolsAction() == MAP_CLEAR_SYMBOLS) { + ofst->SetInputSymbols(nullptr); + } + if (mapper->OutputSymbolsAction() == MAP_COPY_SYMBOLS) { + ofst->SetOutputSymbols(ifst.OutputSymbols()); + } else if (mapper->OutputSymbolsAction() == MAP_CLEAR_SYMBOLS) { + ofst->SetOutputSymbols(nullptr); + } + const auto iprops = ifst.Properties(kCopyProperties, false); + if (ifst.Start() == kNoStateId) { + if (iprops & kError) ofst->SetProperties(kError, kError); + return; + } + // Adds all states. + if (ifst.Properties(kExpanded, false)) ofst->ReserveStates(CountStates(ifst)); + for (StateIterator> siter(ifst); !siter.Done(); siter.Next()) { + ofst->AddState(); + } + ofst->SetStart(mapper->Start()); + for (StateIterator> siter(ifst); !siter.Done(); siter.Next()) { + const auto state = siter.Value(); + mapper->SetState(state); + for (; !mapper->Done(); mapper->Next()) { + ofst->AddArc(state, mapper->Value()); + } + ofst->SetFinal(state, mapper->Final(state)); + } + const auto oprops = ofst->Properties(kFstProperties, false); + ofst->SetProperties(mapper->Properties(iprops) | oprops, kFstProperties); +} + +// Maps an arc type A to an arc type B using mapper functor object C, passed by +// value. This version writes to an output FST. +template +void StateMap(const Fst &ifst, MutableFst *ofst, C mapper) { + StateMap(ifst, ofst, &mapper); +} + +using StateMapFstOptions = CacheOptions; + +template +class StateMapFst; + +// Facade around StateIteratorBase inheriting from StateIteratorBase. +template +class StateMapStateIteratorBase : public StateIteratorBase { + public: + using Arc = B; + using StateId = typename Arc::StateId; + + explicit StateMapStateIteratorBase(StateIteratorBase *base) + : base_(base) {} + + bool Done() const final { return base_->Done(); } + + StateId Value() const final { return base_->Value(); } + + void Next() final { base_->Next(); } + + void Reset() final { base_->Reset(); } + + private: + std::unique_ptr> base_; + + StateMapStateIteratorBase() = delete; +}; + +namespace internal { + +// Implementation of delayed StateMapFst. +template +class StateMapFstImpl : public CacheImpl { + public: + using Arc = B; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using FstImpl::SetType; + using FstImpl::SetProperties; + using FstImpl::SetInputSymbols; + using FstImpl::SetOutputSymbols; + + using CacheImpl::PushArc; + using CacheImpl::HasArcs; + using CacheImpl::HasFinal; + using CacheImpl::HasStart; + using CacheImpl::SetArcs; + using CacheImpl::SetFinal; + using CacheImpl::SetStart; + + friend class StateIterator>; + + StateMapFstImpl(const Fst &fst, const C &mapper, + const StateMapFstOptions &opts) + : CacheImpl(opts), + fst_(fst.Copy()), + mapper_(new C(mapper, fst_.get())), + own_mapper_(true) { + Init(); + } + + StateMapFstImpl(const Fst &fst, C *mapper, const StateMapFstOptions &opts) + : CacheImpl(opts), + fst_(fst.Copy()), + mapper_(mapper), + own_mapper_(false) { + Init(); + } + + StateMapFstImpl(const StateMapFstImpl &impl) + : CacheImpl(impl), + fst_(impl.fst_->Copy(true)), + mapper_(new C(*impl.mapper_, fst_.get())), + own_mapper_(true) { + Init(); + } + + ~StateMapFstImpl() override { + if (own_mapper_) delete mapper_; + } + + StateId Start() { + if (!HasStart()) SetStart(mapper_->Start()); + return CacheImpl::Start(); + } + + Weight Final(StateId state) { + if (!HasFinal(state)) SetFinal(state, mapper_->Final(state)); + return CacheImpl::Final(state); + } + + size_t NumArcs(StateId state) { + if (!HasArcs(state)) Expand(state); + return CacheImpl::NumArcs(state); + } + + size_t NumInputEpsilons(StateId state) { + if (!HasArcs(state)) Expand(state); + return CacheImpl::NumInputEpsilons(state); + } + + size_t NumOutputEpsilons(StateId state) { + if (!HasArcs(state)) Expand(state); + return CacheImpl::NumOutputEpsilons(state); + } + + void InitStateIterator(StateIteratorData *datb) const { + StateIteratorData data; + fst_->InitStateIterator(&data); + datb->base = data.base ? new StateMapStateIteratorBase(data.base) + : nullptr; + datb->nstates = data.nstates; + } + + void InitArcIterator(StateId state, ArcIteratorData *data) { + if (!HasArcs(state)) Expand(state); + CacheImpl::InitArcIterator(state, data); + } + + uint64 Properties() const override { return Properties(kFstProperties); } + + uint64 Properties(uint64 mask) const override { + if ((mask & kError) && (fst_->Properties(kError, false) || + (mapper_->Properties(0) & kError))) { + SetProperties(kError, kError); + } + return FstImpl::Properties(mask); + } + + void Expand(StateId state) { + // Adds exiting arcs. + for (mapper_->SetState(state); !mapper_->Done(); mapper_->Next()) { + PushArc(state, mapper_->Value()); + } + SetArcs(state); + } + + const Fst *GetFst() const { return fst_.get(); } + + private: + void Init() { + SetType("statemap"); + if (mapper_->InputSymbolsAction() == MAP_COPY_SYMBOLS) { + SetInputSymbols(fst_->InputSymbols()); + } else if (mapper_->InputSymbolsAction() == MAP_CLEAR_SYMBOLS) { + SetInputSymbols(nullptr); + } + if (mapper_->OutputSymbolsAction() == MAP_COPY_SYMBOLS) { + SetOutputSymbols(fst_->OutputSymbols()); + } else if (mapper_->OutputSymbolsAction() == MAP_CLEAR_SYMBOLS) { + SetOutputSymbols(nullptr); + } + const auto props = fst_->Properties(kCopyProperties, false); + SetProperties(mapper_->Properties(props)); + } + + std::unique_ptr> fst_; + C *mapper_; + bool own_mapper_; +}; + +} // namespace internal + +// Maps an arc type A to an arc type B using Mapper function object +// C. This version is a delayed FST. +template +class StateMapFst : public ImplToFst> { + public: + friend class ArcIterator>; + + using Arc = B; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + using Store = DefaultCacheStore; + using State = typename Store::State; + using Impl = internal::StateMapFstImpl; + + StateMapFst(const Fst &fst, const C &mapper, + const StateMapFstOptions &opts) + : ImplToFst(std::make_shared(fst, mapper, opts)) {} + + StateMapFst(const Fst &fst, C *mapper, const StateMapFstOptions &opts) + : ImplToFst(std::make_shared(fst, mapper, opts)) {} + + StateMapFst(const Fst &fst, const C &mapper) + : ImplToFst( + std::make_shared(fst, mapper, StateMapFstOptions())) {} + + StateMapFst(const Fst &fst, C *mapper) + : ImplToFst( + std::make_shared(fst, mapper, StateMapFstOptions())) {} + + // See Fst<>::Copy() for doc. + StateMapFst(const StateMapFst &fst, bool safe = false) + : ImplToFst(fst, safe) {} + + // Get a copy of this StateMapFst. See Fst<>::Copy() for further doc. + StateMapFst *Copy(bool safe = false) const override { + return new StateMapFst(*this, safe); + } + + void InitStateIterator(StateIteratorData *data) const override { + GetImpl()->InitStateIterator(data); + } + + void InitArcIterator(StateId state, ArcIteratorData *data) const override { + GetMutableImpl()->InitArcIterator(state, data); + } + + protected: + using ImplToFst::GetImpl; + using ImplToFst::GetMutableImpl; + + private: + StateMapFst &operator=(const StateMapFst &) = delete; +}; + +// Specialization for StateMapFst. +template +class ArcIterator> + : public CacheArcIterator> { + public: + using StateId = typename A::StateId; + + ArcIterator(const StateMapFst &fst, StateId state) + : CacheArcIterator>(fst.GetMutableImpl(), state) { + if (!fst.GetImpl()->HasArcs(state)) fst.GetMutableImpl()->Expand(state); + } +}; + +// Utility mappers. + +// Mapper that returns its input. +template +class IdentityStateMapper { + public: + using FromArc = Arc; + using ToArc = Arc; + + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + explicit IdentityStateMapper(const Fst &fst) : fst_(fst) {} + + // Allows updating FST argument; pass only if changed. + IdentityStateMapper(const IdentityStateMapper &mapper, + const Fst *fst = nullptr) + : fst_(fst ? *fst : mapper.fst_) {} + + StateId Start() const { return fst_.Start(); } + + Weight Final(StateId state) const { return fst_.Final(state); } + + void SetState(StateId state) { + aiter_.reset(new ArcIterator>(fst_, state)); + } + + bool Done() const { return aiter_->Done(); } + + const Arc &Value() const { return aiter_->Value(); } + + void Next() { aiter_->Next(); } + + constexpr MapSymbolsAction InputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + constexpr MapSymbolsAction OutputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + uint64 Properties(uint64 props) const { return props; } + + private: + const Fst &fst_; + std::unique_ptr>> aiter_; +}; + +template +class ArcSumMapper { + public: + using FromArc = Arc; + using ToArc = Arc; + + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + explicit ArcSumMapper(const Fst &fst) : fst_(fst), i_(0) {} + + // Allows updating FST argument; pass only if changed. + ArcSumMapper(const ArcSumMapper &mapper, const Fst *fst = nullptr) + : fst_(fst ? *fst : mapper.fst_), i_(0) {} + + StateId Start() const { return fst_.Start(); } + + Weight Final(StateId state) const { return fst_.Final(state); } + + void SetState(StateId state) { + i_ = 0; + arcs_.clear(); + arcs_.reserve(fst_.NumArcs(state)); + for (ArcIterator> aiter(fst_, state); !aiter.Done(); + aiter.Next()) { + arcs_.push_back(aiter.Value()); + } + // First sorts the exiting arcs by input label, output label and destination + // state and then sums weights of arcs with the same input label, output + // label, and destination state. + std::sort(arcs_.begin(), arcs_.end(), comp_); + size_t narcs = 0; + for (const auto &arc : arcs_) { + if (narcs > 0 && equal_(arc, arcs_[narcs - 1])) { + arcs_[narcs - 1].weight = Plus(arcs_[narcs - 1].weight, arc.weight); + } else { + arcs_[narcs] = arc; + ++narcs; + } + } + arcs_.resize(narcs); + } + + bool Done() const { return i_ >= arcs_.size(); } + + const Arc &Value() const { return arcs_[i_]; } + + void Next() { ++i_; } + + constexpr MapSymbolsAction InputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + constexpr MapSymbolsAction OutputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + uint64 Properties(uint64 props) const { + return props & kArcSortProperties & kDeleteArcsProperties & + kWeightInvariantProperties; + } + + private: + struct Compare { + bool operator()(const Arc &x, const Arc &y) const { + if (x.ilabel < y.ilabel) return true; + if (x.ilabel > y.ilabel) return false; + if (x.olabel < y.olabel) return true; + if (x.olabel > y.olabel) return false; + if (x.nextstate < y.nextstate) return true; + if (x.nextstate > y.nextstate) return false; + return false; + } + }; + + struct Equal { + bool operator()(const Arc &x, const Arc &y) const { + return (x.ilabel == y.ilabel && x.olabel == y.olabel && + x.nextstate == y.nextstate); + } + }; + + const Fst &fst_; + Compare comp_; + Equal equal_; + std::vector arcs_; + ssize_t i_; // Current arc position. + + ArcSumMapper &operator=(const ArcSumMapper &) = delete; +}; + +template +class ArcUniqueMapper { + public: + using FromArc = Arc; + using ToArc = Arc; + + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + explicit ArcUniqueMapper(const Fst &fst) : fst_(fst), i_(0) {} + + // Allows updating FST argument; pass only if changed. + ArcUniqueMapper(const ArcUniqueMapper &mapper, + const Fst *fst = nullptr) + : fst_(fst ? *fst : mapper.fst_), i_(0) {} + + StateId Start() const { return fst_.Start(); } + + Weight Final(StateId state) const { return fst_.Final(state); } + + void SetState(StateId state) { + i_ = 0; + arcs_.clear(); + arcs_.reserve(fst_.NumArcs(state)); + for (ArcIterator> aiter(fst_, state); !aiter.Done(); + aiter.Next()) { + arcs_.push_back(aiter.Value()); + } + // First sorts the exiting arcs by input label, output label and destination + // state and then uniques identical arcs. + std::sort(arcs_.begin(), arcs_.end(), comp_); + arcs_.erase(std::unique(arcs_.begin(), arcs_.end(), equal_), arcs_.end()); + } + + bool Done() const { return i_ >= arcs_.size(); } + + const Arc &Value() const { return arcs_[i_]; } + + void Next() { ++i_; } + + constexpr MapSymbolsAction InputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + constexpr MapSymbolsAction OutputSymbolsAction() const { + return MAP_COPY_SYMBOLS; + } + + uint64 Properties(uint64 props) const { + return props & kArcSortProperties & kDeleteArcsProperties; + } + + private: + struct Compare { + bool operator()(const Arc &x, const Arc &y) const { + if (x.ilabel < y.ilabel) return true; + if (x.ilabel > y.ilabel) return false; + if (x.olabel < y.olabel) return true; + if (x.olabel > y.olabel) return false; + if (x.nextstate < y.nextstate) return true; + if (x.nextstate > y.nextstate) return false; + return false; + } + }; + + struct Equal { + bool operator()(const Arc &x, const Arc &y) const { + return (x.ilabel == y.ilabel && x.olabel == y.olabel && + x.nextstate == y.nextstate && x.weight == y.weight); + } + }; + + const Fst &fst_; + Compare comp_; + Equal equal_; + std::vector arcs_; + size_t i_; // Current arc position. + + ArcUniqueMapper &operator=(const ArcUniqueMapper &) = delete; +}; + +// Useful aliases when using StdArc. + +using StdArcSumMapper = ArcSumMapper; + +using StdArcUniqueMapper = ArcUniqueMapper; + +} // namespace fst + +#endif // FST_STATE_MAP_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/state-reachable.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/state-reachable.h new file mode 100644 index 0000000000..36b5559a28 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/state-reachable.h @@ -0,0 +1,224 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Class to determine whether a given (final) state can be reached from some +// other given state. + +#ifndef FST_STATE_REACHABLE_H_ +#define FST_STATE_REACHABLE_H_ + +#include + +#include + +#include +#include +#include +#include +#include + + +namespace fst { + +// Computes the (final) states reachable from a given state in an FST. After +// this visitor has been called, a final state f can be reached from a state +// s iff (*isets)[s].Member(state2index[f]) is true, where (*isets[s]) is a +// set of half-open inteval of final state indices and state2index[f] maps from +// a final state to its index. If state2index is empty, it is filled-in with +// suitable indices. If it is non-empty, those indices are used; in this case, +// the final states must have out-degree 0. +template > +class IntervalReachVisitor { + public: + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using Index = I; + using ISet = S; + using Interval = typename ISet::Interval; + + IntervalReachVisitor(const Fst &fst, std::vector *isets, + std::vector *state2index) + : fst_(fst), + isets_(isets), + state2index_(state2index), + index_(state2index->empty() ? 1 : -1), + error_(false) { + isets_->clear(); + } + + void InitVisit(const Fst &) { error_ = false; } + + bool InitState(StateId s, StateId r) { + while (isets_->size() <= s) isets_->push_back(S()); + while (state2index_->size() <= s) state2index_->push_back(-1); + if (fst_.Final(s) != Weight::Zero()) { + // Create tree interval. + auto *intervals = (*isets_)[s].MutableIntervals(); + if (index_ < 0) { // Uses state2index_ map to set index. + if (fst_.NumArcs(s) > 0) { + FSTERROR() << "IntervalReachVisitor: state2index map must be empty " + << "for this FST"; + error_ = true; + return false; + } + const auto index = (*state2index_)[s]; + if (index < 0) { + FSTERROR() << "IntervalReachVisitor: state2index map incomplete"; + error_ = true; + return false; + } + intervals->push_back(Interval(index, index + 1)); + } else { // Use pre-order index. + intervals->push_back(Interval(index_, index_ + 1)); + (*state2index_)[s] = index_++; + } + } + return true; + } + + constexpr bool TreeArc(StateId, const Arc &) const { return true; } + + bool BackArc(StateId s, const Arc &arc) { + FSTERROR() << "IntervalReachVisitor: Cyclic input"; + error_ = true; + return false; + } + + bool ForwardOrCrossArc(StateId s, const Arc &arc) { + // Non-tree interval. + (*isets_)[s].Union((*isets_)[arc.nextstate]); + return true; + } + + void FinishState(StateId s, StateId p, const Arc *) { + if (index_ >= 0 && fst_.Final(s) != Weight::Zero()) { + auto *intervals = (*isets_)[s].MutableIntervals(); + (*intervals)[0].end = index_; // Updates tree interval end. + } + (*isets_)[s].Normalize(); + if (p != kNoStateId) { + (*isets_)[p].Union((*isets_)[s]); // Propagates intervals to parent. + } + } + + void FinishVisit() {} + + bool Error() const { return error_; } + + private: + const Fst &fst_; + std::vector *isets_; + std::vector *state2index_; + Index index_; + bool error_; +}; + +// Tests reachability of final states from a given state. To test for +// reachability from a state s, first do SetState(s). Then a final state f can +// be reached from state s of FST iff Reach(f) is true. The input can be cyclic, +// but no cycle may contain a final state. +template > +class StateReachable { + public: + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using Index = I; + using ISet = S; + using Interval = typename ISet::Interval; + + explicit StateReachable(const Fst &fst) : error_(false) { + if (fst.Properties(kAcyclic, true)) { + AcyclicStateReachable(fst); + } else { + CyclicStateReachable(fst); + } + } + + explicit StateReachable(const StateReachable &reachable) { + FSTERROR() << "Copy constructor for state reachable class " + << "not implemented."; + error_ = true; + } + + // Sets current state. + void SetState(StateId s) { s_ = s; } + + // Can reach this final state from current state? + bool Reach(StateId s) { + if (s >= state2index_.size()) return false; + const auto i = state2index_[s]; + if (i < 0) { + FSTERROR() << "StateReachable: State non-final: " << s; + error_ = true; + return false; + } + return isets_[s_].Member(i); + } + + // Access to the state-to-index mapping. Unassigned states have index -1. + std::vector &State2Index() { return state2index_; } + + // Access to the interval sets. These specify the reachability to the final + // states as intervals of the final state indices. + const std::vector &IntervalSets() { return isets_; } + + bool Error() const { return error_; } + + private: + void AcyclicStateReachable(const Fst &fst) { + IntervalReachVisitor reach_visitor(fst, &isets_, + &state2index_); + DfsVisit(fst, &reach_visitor); + if (reach_visitor.Error()) error_ = true; + } + + void CyclicStateReachable(const Fst &fst) { + // Finds state reachability on the acyclic condensation FST. + VectorFst cfst; + std::vector scc; + Condense(fst, &cfst, &scc); + StateReachable reachable(cfst); + if (reachable.Error()) { + error_ = true; + return; + } + // Gets the number of states per SCC. + std::vector nscc; + for (StateId s = 0; s < scc.size(); ++s) { + const auto c = scc[s]; + while (c >= nscc.size()) nscc.push_back(0); + ++nscc[c]; + } + // Constructs the interval sets and state index mapping for the original + // FST from the condensation FST. + state2index_.resize(scc.size(), -1); + isets_.resize(scc.size()); + for (StateId s = 0; s < scc.size(); ++s) { + const auto c = scc[s]; + isets_[s] = reachable.IntervalSets()[c]; + state2index_[s] = reachable.State2Index()[c]; + // Checks that each final state in an input FST is not contained in a + // cycle (i.e., not in a non-trivial SCC). + if (cfst.Final(c) != Weight::Zero() && nscc[c] > 1) { + FSTERROR() << "StateReachable: Final state contained in a cycle"; + error_ = true; + return; + } + } + } + + StateId s_; // Current state. + std::vector isets_; // Interval sets per state. + std::vector state2index_; // Finds index for a final state. + bool error_; + + StateReachable &operator=(const StateReachable &) = delete; +}; + +} // namespace fst + +#endif // FST_STATE_REACHABLE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/state-table.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/state-table.h new file mode 100644 index 0000000000..a50675924b --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/state-table.h @@ -0,0 +1,494 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Classes for representing the mapping between state tuples and state IDs. + +#ifndef FST_STATE_TABLE_H_ +#define FST_STATE_TABLE_H_ + +#include +#include +#include + +#include + +#include +#include +#include + + +namespace fst { + +// State tables determine the bijective mapping between state tuples (e.g., in +// composition, triples of two FST states and a composition filter state) and +// their corresponding state IDs. They are classes, templated on state tuples, +// with the following interface: +// +// template +// class StateTable { +// public: +// using StateTuple = T; +// +// // Required constructors. +// StateTable(); +// +// StateTable(const StateTable &); +// +// // Looks up state ID by tuple. If it doesn't exist, then add it. +// StateId FindState(const StateTuple &tuple); +// +// // Looks up state tuple by state ID. +// const StateTuple &Tuple(StateId s) const; +// +// // # of stored tuples. +// StateId Size() const; +// }; +// +// A state tuple has the form: +// +// template +// struct StateTuple { +// using StateId = S; +// +// // Required constructors. +// +// StateTuple(); +// +// StateTuple(const StateTuple &tuple); +// }; + +// An implementation using a hash map for the tuple to state ID mapping. The +// state tuple T must support operator==. +template +class HashStateTable : public HashBiTable { + public: + using StateTuple = T; + using StateId = typename StateTuple::StateId; + + using HashBiTable::FindId; + using HashBiTable::FindEntry; + using HashBiTable::Size; + + HashStateTable() : HashBiTable() {} + + explicit HashStateTable(size_t table_size) + : HashBiTable(table_size) {} + + StateId FindState(const StateTuple &tuple) { return FindId(tuple); } + + const StateTuple &Tuple(StateId s) const { return FindEntry(s); } +}; + +// An implementation using a hash map for the tuple to state ID mapping. The +// state tuple T must support operator==. +template +class CompactHashStateTable + : public CompactHashBiTable { + public: + using StateTuple = T; + using StateId = typename StateTuple::StateId; + + using CompactHashBiTable::FindId; + using CompactHashBiTable::FindEntry; + using CompactHashBiTable::Size; + + CompactHashStateTable() : CompactHashBiTable() {} + + explicit CompactHashStateTable(size_t table_size) + : CompactHashBiTable(table_size) {} + + StateId FindState(const StateTuple &tuple) { return FindId(tuple); } + + const StateTuple &Tuple(StateId s) const { return FindEntry(s); } +}; + +// An implementation using a vector for the tuple to state mapping. It is +// passed a fingerprint functor that should fingerprint tuples uniquely to an +// integer that can used as a vector index. Normally, VectorStateTable +// constructs the fingerprint functor. Alternately, the user can pass this +// object, in which case the table takes ownership. +template +class VectorStateTable : public VectorBiTable { + public: + using StateTuple = T; + using StateId = typename StateTuple::StateId; + + using VectorBiTable::FindId; + using VectorBiTable::FindEntry; + using VectorBiTable::Size; + using VectorBiTable::Fingerprint; + + explicit VectorStateTable(FP *fingerprint = nullptr, size_t table_size = 0) + : VectorBiTable(fingerprint, table_size) {} + + StateId FindState(const StateTuple &tuple) { return FindId(tuple); } + + const StateTuple &Tuple(StateId s) const { return FindEntry(s); } +}; + +// An implementation using a vector and a compact hash table. The selection +// functor returns true for tuples to be hashed in the vector. The fingerprint +// functor should fingerprint tuples uniquely to an integer that can be used as +// a vector index. A hash functor is used when hashing tuples into the compact +// hash table. +template +class VectorHashStateTable + : public VectorHashBiTable { + public: + using StateTuple = T; + using StateId = typename StateTuple::StateId; + + using VectorHashBiTable::FindId; + using VectorHashBiTable::FindEntry; + using VectorHashBiTable::Size; + using VectorHashBiTable::Selector; + using VectorHashBiTable::Fingerprint; + using VectorHashBiTable::Hash; + + VectorHashStateTable(Select *select, FP *fingerprint, H *hash, + size_t vector_size = 0, size_t tuple_size = 0) + : VectorHashBiTable( + select, fingerprint, hash, vector_size, tuple_size) {} + + StateId FindState(const StateTuple &tuple) { return FindId(tuple); } + + const StateTuple &Tuple(StateId s) const { return FindEntry(s); } +}; + +// An implementation using a hash map to map from tuples to state IDs. This +// version permits erasing of states. The state tuple's default constructor +// must produce a tuple that will never be seen and the table must suppor +// operator==. +template +class ErasableStateTable : public ErasableBiTable { + public: + using StateTuple = T; + using StateId = typename StateTuple::StateId; + + using ErasableBiTable::FindId; + using ErasableBiTable::FindEntry; + using ErasableBiTable::Size; + using ErasableBiTable::Erase; + + ErasableStateTable() : ErasableBiTable() {} + + StateId FindState(const StateTuple &tuple) { return FindId(tuple); } + + const StateTuple &Tuple(StateId s) const { return FindEntry(s); } +}; + +// The composition state table has the form: +// +// template +// class ComposeStateTable { +// public: +// using StateId = typename Arc::StateId; +// +// // Required constructors. +// +// ComposeStateTable(const Fst &fst1, const Fst &fst2); +// ComposeStateTable(const ComposeStateTable &table); +// +// // Looks up a state ID by tuple, adding it if doesn't exist. +// StateId FindState(const StateTuple &tuple); +// +// // Looks up a tuple by state ID. +// const ComposeStateTuple &Tuple(StateId s) const; +// +// // The number of of stored tuples. +// StateId Size() const; +// +// // Return true if error was encountered. +// bool Error() const; +// }; +// +// The following interface is used to represent the composition state. +// +// template +// class CompositionStateTuple { +// public: +// using StateId = typename StateId; +// using FS = FilterState; +// +// // Required constructors. +// StateTuple(); +// StateTuple(StateId s1, StateId s2, const FilterState &fs); +// +// StateId StateId1() const; +// StateId StateId2() const; +// +// FilterState GetFilterState() const; +// +// std::pair StatePair() const; +// +// size_t Hash() const; +// +// friend bool operator==(const StateTuple& x, const StateTuple &y); +// } +// +template +class DefaultComposeStateTuple { + public: + using StateId = S; + using FilterState = FS; + + DefaultComposeStateTuple() + : state_pair_(kNoStateId, kNoStateId), fs_(FilterState::NoState()) {} + + DefaultComposeStateTuple(StateId s1, StateId s2, const FilterState &fs) + : state_pair_(s1, s2), fs_(fs) {} + + StateId StateId1() const { return state_pair_.first; } + + StateId StateId2() const { return state_pair_.second; } + + FilterState GetFilterState() const { return fs_; } + + const std::pair &StatePair() const { return state_pair_; } + + friend bool operator==(const DefaultComposeStateTuple &x, + const DefaultComposeStateTuple &y) { + return (&x == &y) || (x.state_pair_ == y.state_pair_ && x.fs_ == y.fs_); + } + + size_t Hash() const { + return static_cast(StateId1()) + + static_cast(StateId2()) * 7853u + + GetFilterState().Hash() * 7867u; + } + + private: + std::pair state_pair_; + FilterState fs_; // State of composition filter. +}; + +// Specialization for TrivialFilterState that does not explicitely store the +// filter state since it is always the unique non-blocking state. +template +class DefaultComposeStateTuple { + public: + using StateId = S; + using FilterState = TrivialFilterState; + + DefaultComposeStateTuple() + : state_pair_(kNoStateId, kNoStateId) {} + + DefaultComposeStateTuple(StateId s1, StateId s2, const FilterState &) + : state_pair_(s1, s2) {} + + StateId StateId1() const { return state_pair_.first; } + + StateId StateId2() const { return state_pair_.second; } + + FilterState GetFilterState() const { return FilterState(true); } + + const std::pair &StatePair() const { return state_pair_; } + + friend bool operator==(const DefaultComposeStateTuple &x, + const DefaultComposeStateTuple &y) { + return (&x == &y) || (x.state_pair_ == y.state_pair_); + } + + size_t Hash() const { return StateId1() + StateId2() * 7853; } + + private: + std::pair state_pair_; +}; + +// Hashing of composition state tuples. +template +class ComposeHash { + public: + size_t operator()(const T &t) const { return t.Hash(); } +}; + +// A HashStateTable over composition tuples. +template , + typename StateTable = + CompactHashStateTable>> +class GenericComposeStateTable : public StateTable { + public: + using StateId = typename Arc::StateId; + + GenericComposeStateTable(const Fst &fst1, const Fst &fst2) {} + + GenericComposeStateTable(const Fst &fst1, const Fst &fst2, + size_t table_size) + : StateTable(table_size) {} + + constexpr bool Error() const { return false; } + + private: + GenericComposeStateTable &operator=(const GenericComposeStateTable &table) = + delete; +}; + +// Fingerprint for general composition tuples. +template +class ComposeFingerprint { + public: + using StateId = typename StateTuple::StateId; + + // Required but suboptimal constructor. + ComposeFingerprint() : mult1_(8192), mult2_(8192) { + LOG(WARNING) << "TupleFingerprint: # of FST states should be provided."; + } + + // Constructor is provided the sizes of the input FSTs. + ComposeFingerprint(StateId nstates1, StateId nstates2) + : mult1_(nstates1), mult2_(nstates1 * nstates2) {} + + size_t operator()(const StateTuple &tuple) { + return tuple.StateId1() + tuple.StateId2() * mult1_ + + tuple.GetFilterState().Hash() * mult2_; + } + + private: + const ssize_t mult1_; + const ssize_t mult2_; +}; + +// Useful when the first composition state determines the tuple. +template +class ComposeState1Fingerprint { + public: + size_t operator()(const StateTuple &tuple) { return tuple.StateId1(); } +}; + +// Useful when the second composition state determines the tuple. +template +class ComposeState2Fingerprint { + public: + size_t operator()(const StateTuple &tuple) { return tuple.StateId2(); } +}; + +// A VectorStateTable over composition tuples. This can be used when the +// product of number of states in FST1 and FST2 (and the composition filter +// state hash) is manageable. If the FSTs are not expanded FSTs, they will +// first have their states counted. +template +class ProductComposeStateTable + : public VectorStateTable> { + public: + using StateId = typename Arc::StateId; + using StateTable = + VectorStateTable>; + + ProductComposeStateTable(const Fst &fst1, const Fst &fst2, + size_t table_size = 0) + : StateTable(new ComposeFingerprint(CountStates(fst1), + CountStates(fst2)), + table_size) {} + + ProductComposeStateTable( + const ProductComposeStateTable &table) + : StateTable(new ComposeFingerprint(table.Fingerprint())) {} + + constexpr bool Error() const { return false; } + + private: + ProductComposeStateTable &operator=(const ProductComposeStateTable &table) = + delete; +}; + +// A vector-backed table over composition tuples which can be used when the +// first FST is a string (i.e., satisfies kString property) and the second is +// deterministic and epsilon-free. It should be used with a composition filter +// that creates at most one filter state per tuple under these conditions (e.g., +// SequenceComposeFilter or MatchComposeFilter). +template +class StringDetComposeStateTable + : public VectorStateTable> { + public: + using StateId = typename Arc::StateId; + using StateTable = + VectorStateTable>; + + StringDetComposeStateTable(const Fst &fst1, const Fst &fst2) + : error_(false) { + static constexpr auto props2 = kIDeterministic | kNoIEpsilons; + if (fst1.Properties(kString, true) != kString) { + FSTERROR() << "StringDetComposeStateTable: 1st FST is not a string"; + error_ = true; + } else if (fst2.Properties(props2, true) != props2) { + FSTERROR() << "StringDetComposeStateTable: 2nd FST is not deterministic " + "and epsilon-free"; + error_ = true; + } + } + + StringDetComposeStateTable( + const StringDetComposeStateTable &table) + : StateTable(table), error_(table.error_) {} + + bool Error() const { return error_; } + + private: + bool error_; + + StringDetComposeStateTable &operator=(const StringDetComposeStateTable &) = + delete; +}; + +// A vector-backed table over composition tuples which can be used when the +// first FST is deterministic and epsilon-free and the second is a string (i.e., +// satisfies kString). It should be used with a composition filter that creates +// at most one filter state per tuple under these conditions (e.g., +// SequenceComposeFilter or MatchComposeFilter). +template +class DetStringComposeStateTable + : public VectorStateTable> { + public: + using StateId = typename Arc::StateId; + using StateTable = + VectorStateTable>; + + DetStringComposeStateTable(const Fst &fst1, const Fst &fst2) + : error_(false) { + static constexpr auto props = kODeterministic | kNoOEpsilons; + if (fst1.Properties(props, true) != props) { + FSTERROR() << "StringDetComposeStateTable: 1st FST is not " + << "input-deterministic and epsilon-free"; + error_ = true; + } else if (fst2.Properties(kString, true) != kString) { + FSTERROR() << "DetStringComposeStateTable: 2nd FST is not a string"; + error_ = true; + } + } + + DetStringComposeStateTable( + const DetStringComposeStateTable &table) + : StateTable(table), error_(table.error_) {} + + bool Error() const { return error_; } + + private: + bool error_; + + DetStringComposeStateTable &operator=(const DetStringComposeStateTable &) = + delete; +}; + +// An erasable table over composition tuples. The Erase(StateId) method can be +// called if the user either is sure that composition will never return to that +// tuple or doesn't care that if it does, it is assigned a new state ID. +template +class ErasableComposeStateTable + : public ErasableStateTable> { + public: + ErasableComposeStateTable(const Fst &fst1, const Fst &fst2) {} + + constexpr bool Error() const { return false; } + + private: + ErasableComposeStateTable &operator=(const ErasableComposeStateTable &table) = + delete; +}; + +} // namespace fst + +#endif // FST_STATE_TABLE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/statesort.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/statesort.h new file mode 100644 index 0000000000..346c7d32b8 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/statesort.h @@ -0,0 +1,74 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Function to sort states of an FST. + +#ifndef FST_STATESORT_H_ +#define FST_STATESORT_H_ + +#include +#include + +#include + +#include + + +namespace fst { + +// Sorts the input states of an FST. order[i] gives the the state ID after +// sorting that corresponds to the state ID i before sorting; it must +// therefore be a permutation of the input FST's states ID sequence. +template +void StateSort(MutableFst *fst, + const std::vector &order) { + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + if (order.size() != fst->NumStates()) { + FSTERROR() << "StateSort: Bad order vector size: " << order.size(); + fst->SetProperties(kError, kError); + return; + } + if (fst->Start() == kNoStateId) return; + const auto props = fst->Properties(kStateSortProperties, false); + std::vector done(order.size(), false); + std::vector arcsa; + std::vector arcsb; + fst->SetStart(order[fst->Start()]); + for (StateIterator> siter(*fst); !siter.Done(); + siter.Next()) { + auto s1 = siter.Value(); + StateId s2; + if (done[s1]) continue; + auto final1 = fst->Final(s1); + auto final2 = Weight::Zero(); + arcsa.clear(); + for (ArcIterator> aiter(*fst, s1); !aiter.Done(); + aiter.Next()) { + arcsa.push_back(aiter.Value()); + } + for (; !done[s1]; s1 = s2, final1 = final2, std::swap(arcsa, arcsb)) { + s2 = order[s1]; + if (!done[s2]) { + final2 = fst->Final(s2); + arcsb.clear(); + for (ArcIterator> aiter(*fst, s2); !aiter.Done(); + aiter.Next()) { + arcsb.push_back(aiter.Value()); + } + } + fst->SetFinal(s2, final1); + fst->DeleteArcs(s2); + for (auto arc : arcsa) { // Copy intended. + arc.nextstate = order[arc.nextstate]; + fst->AddArc(s2, arc); + } + done[s1] = true; + } + } + fst->SetProperties(props, kFstProperties); +} + +} // namespace fst + +#endif // FST_STATESORT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/string-weight.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/string-weight.h new file mode 100644 index 0000000000..8bd9e36f2c --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/string-weight.h @@ -0,0 +1,807 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// String weight set and associated semiring operation definitions. + +#ifndef FST_STRING_WEIGHT_H_ +#define FST_STRING_WEIGHT_H_ + +#include + +#include +#include +#include + +#include +#include +#include + + +namespace fst { + +constexpr int kStringInfinity = -1; // Label for the infinite string. +constexpr int kStringBad = -2; // Label for a non-string. +constexpr char kStringSeparator = '_'; // Label separator in strings. + +// Determines whether to use left or right string semiring. Includes a +// 'restricted' version that signals an error if proper prefixes/suffixes +// would otherwise be returned by Plus, useful with various +// algorithms that require functional transducer input with the +// string semirings. +enum StringType { STRING_LEFT = 0, STRING_RIGHT = 1, STRING_RESTRICT = 2 }; + +constexpr StringType ReverseStringType(StringType s) { + return s == STRING_LEFT ? STRING_RIGHT + : (s == STRING_RIGHT ? STRING_LEFT : STRING_RESTRICT); +} + +template +class StringWeightIterator; +template +class StringWeightReverseIterator; + +// String semiring: (longest_common_prefix/suffix, ., Infinity, Epsilon) +template +class StringWeight { + public: + using Label = Label_; + using ReverseWeight = StringWeight; + using Iterator = StringWeightIterator; + using ReverseIterator = StringWeightReverseIterator; + + friend class StringWeightIterator; + friend class StringWeightReverseIterator; + + StringWeight() {} + + template + StringWeight(const Iterator &begin, const Iterator &end) { + for (auto iter = begin; iter != end; ++iter) PushBack(*iter); + } + + explicit StringWeight(Label label) { PushBack(label); } + + static const StringWeight &Zero() { + static const auto *const zero = new StringWeight(Label(kStringInfinity)); + return *zero; + } + + static const StringWeight &One() { + static const auto *const one = new StringWeight(); + return *one; + } + + static const StringWeight &NoWeight() { + static const auto *const no_weight = new StringWeight(Label(kStringBad)); + return *no_weight; + } + + static const string &Type() { + static const string *const type = new string( + S == STRING_LEFT + ? "left_string" + : (S == STRING_RIGHT ? "right_string" : "restricted_string")); + return *type; + } + + bool Member() const; + + std::istream &Read(std::istream &strm); + + std::ostream &Write(std::ostream &strm) const; + + size_t Hash() const; + + StringWeight Quantize(float delta = kDelta) const { return *this; } + + ReverseWeight Reverse() const; + + static constexpr uint64 Properties() { + return kIdempotent | + (S == STRING_LEFT ? kLeftSemiring + : (S == STRING_RIGHT + ? kRightSemiring + : /* S == STRING_RESTRICT */ kLeftSemiring | + kRightSemiring)); + } + + // These operations combined with the StringWeightIterator and + // StringWeightReverseIterator provide the access and mutation of the string + // internal elements. + + // Clear existing StringWeight. + void Clear() { + first_ = 0; + rest_.clear(); + } + + size_t Size() const { return first_ ? rest_.size() + 1 : 0; } + + void PushFront(Label label) { + if (first_) rest_.push_front(first_); + first_ = label; + } + + void PushBack(Label label) { + if (!first_) { + first_ = label; + } else { + rest_.push_back(label); + } + } + + private: + Label first_ = 0; // First label in string (0 if empty). + std::list; + + friend class ArcIterator>; + friend class StateIterator>; + + explicit SynchronizeFst( + const Fst &fst, + const SynchronizeFstOptions &opts = SynchronizeFstOptions()) + : ImplToFst(std::make_shared(fst, opts)) {} + + // See Fst<>::Copy() for doc. + SynchronizeFst(const SynchronizeFst &fst, bool safe = false) + : ImplToFst(fst, safe) {} + + // Gets a copy of this SynchronizeFst. See Fst<>::Copy() for further doc. + SynchronizeFst *Copy(bool safe = false) const override { + return new SynchronizeFst(*this, safe); + } + + inline void InitStateIterator(StateIteratorData *data) const override; + + void InitArcIterator(StateId s, ArcIteratorData *data) const override { + GetMutableImpl()->InitArcIterator(s, data); + } + + private: + using ImplToFst::GetImpl; + using ImplToFst::GetMutableImpl; + + SynchronizeFst &operator=(const SynchronizeFst &) = delete; +}; + +// Specialization for SynchronizeFst. +template +class StateIterator> + : public CacheStateIterator> { + public: + explicit StateIterator(const SynchronizeFst &fst) + : CacheStateIterator>(fst, fst.GetMutableImpl()) {} +}; + +// Specialization for SynchronizeFst. +template +class ArcIterator> + : public CacheArcIterator> { + public: + using StateId = typename Arc::StateId; + + ArcIterator(const SynchronizeFst &fst, StateId s) + : CacheArcIterator>(fst.GetMutableImpl(), s) { + if (!fst.GetImpl()->HasArcs(s)) fst.GetMutableImpl()->Expand(s); + } +}; + +template +inline void SynchronizeFst::InitStateIterator( + StateIteratorData *data) const { + data->base = new StateIterator>(*this); +} + +// Synchronizes a transducer. This version writes the synchronized result to a +// MutableFst. The result will be an equivalent FST that has the property that +// during the traversal of a path, the delay is either zero or strictly +// increasing, where the delay is the difference between the number of +// non-epsilon output labels and input labels along the path. +// +// For the algorithm to terminate, the input transducer must have bounded +// delay, i.e., the delay of every cycle must be zero. +// +// Complexity: +// +// - A has bounded delay: exponential. +// - A does not have bounded delay: does not terminate. +// +// For more information, see: +// +// Mohri, M. 2003. Edit-distance of weighted automata: General definitions and +// algorithms. International Journal of Computer Science 14(6): 957-982. +template +void Synchronize(const Fst &ifst, MutableFst *ofst) { + // Caches only the last state for fastest copy. + const SynchronizeFstOptions opts(FLAGS_fst_default_cache_gc, 0); + *ofst = SynchronizeFst(ifst, opts); +} + +} // namespace fst + +#endif // FST_SYNCHRONIZE_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/test-properties.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/test-properties.h new file mode 100644 index 0000000000..677ed01b72 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/test-properties.h @@ -0,0 +1,246 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Functions to manipulate and test property bits. + +#ifndef FST_TEST_PROPERTIES_H_ +#define FST_TEST_PROPERTIES_H_ + +#include + +#include +#include + +#include +#include + + +DECLARE_bool(fst_verify_properties); + +namespace fst { +// namespace internal { + +// For a binary property, the bit is always returned set. For a trinary (i.e., +// two-bit) property, both bits are returned set iff either corresponding input +// bit is set. +inline uint64 KnownProperties(uint64 props) { + return kBinaryProperties | (props & kTrinaryProperties) | + ((props & kPosTrinaryProperties) << 1) | + ((props & kNegTrinaryProperties) >> 1); +} + +// Tests compatibility between two sets of properties. +inline bool CompatProperties(uint64 props1, uint64 props2) { + const auto known_props1 = KnownProperties(props1); + const auto known_props2 = KnownProperties(props2); + const auto known_props = known_props1 & known_props2; + const auto incompat_props = (props1 & known_props) ^ (props2 & known_props); + if (incompat_props) { + uint64 prop = 1; + for (int i = 0; i < 64; ++i, prop <<= 1) { + if (prop & incompat_props) { + LOG(ERROR) << "CompatProperties: Mismatch: " << PropertyNames[i] + << ": props1 = " << (props1 & prop ? "true" : "false") + << ", props2 = " << (props2 & prop ? "true" : "false"); + } + } + return false; + } else { + return true; + } +} + +// Computes FST property values defined in properties.h. The value of each +// property indicated in the mask will be determined and returned (these will +// never be unknown here). In the course of determining the properties +// specifically requested in the mask, certain other properties may be +// determined (those with little additional expense) and their values will be +// returned as well. The complete set of known properties (whether true or +// false) determined by this operation will be assigned to the the value pointed +// to by KNOWN. If 'use_stored' is true, pre-computed FST properties may be used +// when possible. 'mask & required_mask' is used to determine whether the stored +// propertoes can be used. This routine is seldom called directly; instead it is +// used to implement fst.Properties(mask, true). +template +uint64 ComputeProperties(const Fst &fst, uint64 mask, uint64 *known, + bool use_stored) { + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + const auto fst_props = fst.Properties(kFstProperties, false); // FST-stored. + // Check stored FST properties first if allowed. + if (use_stored) { + const auto known_props = KnownProperties(fst_props); + // If FST contains required info, return it. + if ((known_props & mask) == mask) { + if (known) *known = known_props; + return fst_props; + } + } + // Computes (trinary) properties explicitly. + // Initialize with binary properties (already known). + uint64 comp_props = fst_props & kBinaryProperties; + // Computes these trinary properties with a DFS. We compute only those that + // need a DFS here, since we otherwise would like to avoid a DFS since its + // stack could grow large. + uint64 dfs_props = kCyclic | kAcyclic | kInitialCyclic | kInitialAcyclic | + kAccessible | kNotAccessible | kCoAccessible | + kNotCoAccessible; + std::vector scc; + if (mask & (dfs_props | kWeightedCycles | kUnweightedCycles)) { + SccVisitor scc_visitor(&scc, nullptr, nullptr, &comp_props); + DfsVisit(fst, &scc_visitor); + } + // Computes any remaining trinary properties via a state and arcs iterations + if (mask & ~(kBinaryProperties | dfs_props)) { + comp_props |= kAcceptor | kNoEpsilons | kNoIEpsilons | kNoOEpsilons | + kILabelSorted | kOLabelSorted | kUnweighted | kTopSorted | + kString; + if (mask & (kIDeterministic | kNonIDeterministic)) { + comp_props |= kIDeterministic; + } + if (mask & (kODeterministic | kNonODeterministic)) { + comp_props |= kODeterministic; + } + if (mask & (dfs_props | kWeightedCycles | kUnweightedCycles)) { + comp_props |= kUnweightedCycles; + } + std::unique_ptr> ilabels; + std::unique_ptr> olabels; + StateId nfinal = 0; + for (StateIterator> siter(fst); !siter.Done(); siter.Next()) { + StateId s = siter.Value(); + Arc prev_arc; + // Creates these only if we need to. + if (mask & (kIDeterministic | kNonIDeterministic)) { + ilabels.reset(new std::unordered_set { + public: + using Arc = A; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + UnionFst(const Fst &fst1, const Fst &fst2) { + GetMutableImpl()->InitUnion(fst1, fst2); + } + + UnionFst(const Fst &fst1, const Fst &fst2, + const UnionFstOptions &opts) + : RationalFst(opts) { + GetMutableImpl()->InitUnion(fst1, fst2); + } + + // See Fst<>::Copy() for doc. + UnionFst(const UnionFst &fst, bool safe = false) + : RationalFst(fst, safe) {} + + // Gets a copy of this UnionFst. See Fst<>::Copy() for further doc. + UnionFst *Copy(bool safe = false) const override { + return new UnionFst(*this, safe); + } + + private: + using ImplToFst>::GetImpl; + using ImplToFst>::GetMutableImpl; +}; + +// Specialization for UnionFst. +template +class StateIterator> : public StateIterator> { + public: + explicit StateIterator(const UnionFst &fst) + : StateIterator>(fst) {} +}; + +// Specialization for UnionFst. +template +class ArcIterator> : public ArcIterator> { + public: + using StateId = typename Arc::StateId; + + ArcIterator(const UnionFst &fst, StateId s) + : ArcIterator>(fst, s) {} +}; + +using StdUnionFst = UnionFst; + +} // namespace fst + +#endif // FST_UNION_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/util.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/util.h new file mode 100644 index 0000000000..f75a9d4f01 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/util.h @@ -0,0 +1,428 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// FST utility inline definitions. + +#ifndef FST_UTIL_H_ +#define FST_UTIL_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include + + +// Utility for error handling. + +DECLARE_bool(fst_error_fatal); + +#define FSTERROR() \ + (FLAGS_fst_error_fatal ? LOG(FATAL) : LOG(ERROR)) + +namespace fst { + +// Utility for type I/O. + +// Reads types from an input stream. + +// Generic case. +template ::value, T>::type* = nullptr> +inline std::istream &ReadType(std::istream &strm, T *t) { + return t->Read(strm); +} + +// Numeric (boolean, integral, floating-point) case. +template ::value, T>::type* = nullptr> +inline std::istream &ReadType(std::istream &strm, T *t) { + return strm.read(reinterpret_cast(t), sizeof(T)); \ +} + +// String case. +inline std::istream &ReadType(std::istream &strm, string *s) { // NOLINT + s->clear(); + int32 ns = 0; + strm.read(reinterpret_cast(&ns), sizeof(ns)); + for (int32 i = 0; i < ns; ++i) { + char c; + strm.read(&c, 1); + *s += c; + } + return strm; +} + +// Declares types that can be read from an input stream. +template +std::istream &ReadType(std::istream &strm, std::vector *c); +template +std::istream &ReadType(std::istream &strm, std::list *c); +template +std::istream &ReadType(std::istream &strm, std::set *c); +template +std::istream &ReadType(std::istream &strm, std::map *c); +template +std::istream &ReadType(std::istream &strm, std::unordered_map *c); +template +std::istream &ReadType(std::istream &strm, std::unordered_set *c); + +// Pair case. +template +inline std::istream &ReadType(std::istream &strm, std::pair *p) { + ReadType(strm, &p->first); + ReadType(strm, &p->second); + return strm; +} + +template +inline std::istream &ReadType(std::istream &strm, std::pair *p) { + ReadType(strm, const_cast(&p->first)); + ReadType(strm, &p->second); + return strm; +} + +namespace internal { +template +std::istream &ReadContainerType(std::istream &strm, C *c, ReserveFn reserve) { + c->clear(); + int64 n = 0; + ReadType(strm, &n); + reserve(c, n); + auto insert = std::inserter(*c, c->begin()); + for (int64 i = 0; i < n; ++i) { + typename C::value_type value; + ReadType(strm, &value); + *insert = value; + } + return strm; +} +} // namespace internal + +template +std::istream &ReadType(std::istream &strm, std::vector *c) { + return internal::ReadContainerType( + strm, c, [](decltype(c) v, int n) { v->reserve(n); }); +} + +template +std::istream &ReadType(std::istream &strm, std::list *c) { + return internal::ReadContainerType(strm, c, [](decltype(c) v, int n) {}); +} + +template +std::istream &ReadType(std::istream &strm, std::set *c) { + return internal::ReadContainerType(strm, c, [](decltype(c) v, int n) {}); +} + +template +std::istream &ReadType(std::istream &strm, std::map *c) { + return internal::ReadContainerType(strm, c, [](decltype(c) v, int n) {}); +} + +template +std::istream &ReadType(std::istream &strm, std::unordered_set *c) { + return internal::ReadContainerType( + strm, c, [](decltype(c) v, int n) { v->reserve(n); }); +} + +template +std::istream &ReadType(std::istream &strm, std::unordered_map *c) { + return internal::ReadContainerType( + strm, c, [](decltype(c) v, int n) { v->reserve(n); }); +} + +// Writes types to an output stream. + +// Generic case. +template ::value, T>::type* = nullptr> +inline std::ostream &WriteType(std::ostream &strm, const T t) { + t.Write(strm); + return strm; +} + +// Numeric (boolean, integral, floating-point) case. +template ::value, T>::type* = nullptr> +inline std::ostream &WriteType(std::ostream &strm, const T t) { + return strm.write(reinterpret_cast(&t), sizeof(T)); +} + +// String case. +inline std::ostream &WriteType(std::ostream &strm, const string &s) { // NOLINT + int32 ns = s.size(); + strm.write(reinterpret_cast(&ns), sizeof(ns)); + return strm.write(s.data(), ns); +} + +// Declares types that can be written to an output stream. + +template +std::ostream &WriteType(std::ostream &strm, const std::vector &c); +template +std::ostream &WriteType(std::ostream &strm, const std::list &c); +template +std::ostream &WriteType(std::ostream &strm, const std::set &c); +template +std::ostream &WriteType(std::ostream &strm, const std::map &c); +template +std::ostream &WriteType(std::ostream &strm, const std::unordered_map &c); +template +std::ostream &WriteType(std::ostream &strm, const std::unordered_set &c); + +// Pair case. +template +inline std::ostream &WriteType(std::ostream &strm, + const std::pair &p) { // NOLINT + WriteType(strm, p.first); + WriteType(strm, p.second); + return strm; +} + +namespace internal { +template +std::ostream &WriteContainer(std::ostream &strm, const C &c) { + const int64 n = c.size(); + WriteType(strm, n); + for (const auto &e : c) { + WriteType(strm, e); + } + return strm; +} +} // namespace internal + +template +std::ostream &WriteType(std::ostream &strm, const std::vector &c) { + return internal::WriteContainer(strm, c); +} + +template +std::ostream &WriteType(std::ostream &strm, const std::list &c) { + return internal::WriteContainer(strm, c); +} + +template +std::ostream &WriteType(std::ostream &strm, const std::set &c) { + return internal::WriteContainer(strm, c); +} + +template +std::ostream &WriteType(std::ostream &strm, const std::map &c) { + return internal::WriteContainer(strm, c); +} + +template +std::ostream &WriteType(std::ostream &strm, const std::unordered_map &c) { + return internal::WriteContainer(strm, c); +} + +template +std::ostream &WriteType(std::ostream &strm, const std::unordered_set &c) { + return internal::WriteContainer(strm, c); +} + +// Utilities for converting between int64 or Weight and string. + +int64 StrToInt64(const string &s, const string &src, size_t nline, + bool allow_negative, bool *error = nullptr); + +template +Weight StrToWeight(const string &s, const string &src, size_t nline) { + Weight w; + std::istringstream strm(s); + strm >> w; + if (!strm) { + FSTERROR() << "StrToWeight: Bad weight = \"" << s << "\", source = " << src + << ", line = " << nline; + return Weight::NoWeight(); + } + return w; +} + +template +void WeightToStr(Weight w, string *s) { + std::ostringstream strm; + strm.precision(9); + strm << w; + s->append(strm.str().data(), strm.str().size()); +} + +// Utilities for reading/writing integer pairs (typically labels) + +// Modifies line using a vector of pointers to a buffer beginning with line. +void SplitString(char *line, const char *delim, std::vector *vec, + bool omit_empty_strings); + +template +bool ReadIntPairs(const string &filename, std::vector> *pairs, + bool allow_negative = false) { + std::ifstream strm(filename, std::ios_base::in); + if (!strm) { + LOG(ERROR) << "ReadIntPairs: Can't open file: " << filename; + return false; + } + const int kLineLen = 8096; + char line[kLineLen]; + size_t nline = 0; + pairs->clear(); + while (strm.getline(line, kLineLen)) { + ++nline; + std::vector col; + SplitString(line, "\n\t ", &col, true); + // empty line or comment? + if (col.empty() || col[0][0] == '\0' || col[0][0] == '#') continue; + if (col.size() != 2) { + LOG(ERROR) << "ReadIntPairs: Bad number of columns, " + << "file = " << filename << ", line = " << nline; + return false; + } + bool err; + I i1 = StrToInt64(col[0], filename, nline, allow_negative, &err); + if (err) return false; + I i2 = StrToInt64(col[1], filename, nline, allow_negative, &err); + if (err) return false; + pairs->push_back(std::make_pair(i1, i2)); + } + return true; +} + +template +bool WriteIntPairs(const string &filename, + const std::vector> &pairs) { + std::ostream *strm = &std::cout; + if (!filename.empty()) { + strm = new std::ofstream(filename); + if (!*strm) { + LOG(ERROR) << "WriteIntPairs: Can't open file: " << filename; + return false; + } + } + for (ssize_t n = 0; n < pairs.size(); ++n) { + *strm << pairs[n].first << "\t" << pairs[n].second << "\n"; + } + if (!*strm) { + LOG(ERROR) << "WriteIntPairs: Write failed: " + << (filename.empty() ? "standard output" : filename); + return false; + } + if (strm != &std::cout) delete strm; + return true; +} + +// Utilities for reading/writing label pairs. + +template +bool ReadLabelPairs(const string &filename, + std::vector> *pairs, + bool allow_negative = false) { + return ReadIntPairs(filename, pairs, allow_negative); +} + +template +bool WriteLabelPairs(const string &filename, + const std::vector> &pairs) { + return WriteIntPairs(filename, pairs); +} + +// Utilities for converting a type name to a legal C symbol. + +void ConvertToLegalCSymbol(string *s); + +// Utilities for stream I/O. + +bool AlignInput(std::istream &strm); +bool AlignOutput(std::ostream &strm); + +// An associative container for which testing membership is faster than an STL +// set if members are restricted to an interval that excludes most non-members. +// A Key must have ==, !=, and < operators defined. Element NoKey should be a +// key that marks an uninitialized key and is otherwise unused. Find() returns +// an STL const_iterator to the match found, otherwise it equals End(). +template +class CompactSet { + public: + using const_iterator = typename std::set::const_iterator; + + CompactSet() : min_key_(NoKey), max_key_(NoKey) {} + + CompactSet(const CompactSet &compact_set) + : set_(compact_set.set_), + min_key_(compact_set.min_key_), + max_key_(compact_set.max_key_) {} + + void Insert(Key key) { + set_.insert(key); + if (min_key_ == NoKey || key < min_key_) min_key_ = key; + if (max_key_ == NoKey || max_key_ < key) max_key_ = key; + } + + void Erase(Key key) { + set_.erase(key); + if (set_.empty()) { + min_key_ = max_key_ = NoKey; + } else if (key == min_key_) { + ++min_key_; + } else if (key == max_key_) { + --max_key_; + } + } + + void Clear() { + set_.clear(); + min_key_ = max_key_ = NoKey; + } + + const_iterator Find(Key key) const { + if (min_key_ == NoKey || key < min_key_ || max_key_ < key) { + return set_.end(); + } else { + return set_.find(key); + } + } + + bool Member(Key key) const { + if (min_key_ == NoKey || key < min_key_ || max_key_ < key) { + return false; // out of range + } else if (min_key_ != NoKey && max_key_ + 1 == min_key_ + set_.size()) { + return true; // dense range + } else { + return set_.count(key); + } + } + + const_iterator Begin() const { return set_.begin(); } + + const_iterator End() const { return set_.end(); } + + // All stored keys are greater than or equal to this value. + Key LowerBound() const { return min_key_; } + + // All stored keys are less than or equal to this value. + Key UpperBound() const { return max_key_; } + + private: + std::set set_; + Key min_key_; + Key max_key_; + + void operator=(const CompactSet &) = delete; +}; + +} // namespace fst + +#endif // FST_UTIL_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/vector-fst.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/vector-fst.h new file mode 100644 index 0000000000..49e99fd123 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/vector-fst.h @@ -0,0 +1,719 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Simple concrete, mutable FST whose states and arcs are stored in STL vectors. + +#ifndef FST_VECTOR_FST_H_ +#define FST_VECTOR_FST_H_ + +#include +#include +#include + +#include + +#include // For optional argument declarations +#include +#include + + +namespace fst { + +template +class VectorFst; + +template +void Cast(const F &, G *); + +// Arcs (of type A) implemented by an STL vector per state. M specifies Arc +// allocator (default declared in fst-decl.h). +template */> +class VectorState { + public: + using Arc = A; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + using ArcAllocator = M; + using StateAllocator = + typename ArcAllocator::template rebind>::other; + + // Provide STL allocator for arcs. + explicit VectorState(const ArcAllocator &alloc) + : final_(Weight::Zero()), niepsilons_(0), noepsilons_(0), arcs_(alloc) {} + + VectorState(const VectorState &state, const ArcAllocator &alloc) + : final_(state.Final()), + niepsilons_(state.NumInputEpsilons()), + noepsilons_(state.NumOutputEpsilons()), + arcs_(state.arcs_.begin(), state.arcs_.end(), alloc) {} + + void Reset() { + final_ = Weight::Zero(); + niepsilons_ = 0; + noepsilons_ = 0; + arcs_.clear(); + } + + Weight Final() const { return final_; } + + size_t NumInputEpsilons() const { return niepsilons_; } + + size_t NumOutputEpsilons() const { return noepsilons_; } + + size_t NumArcs() const { return arcs_.size(); } + + const Arc &GetArc(size_t n) const { return arcs_[n]; } + + const Arc *Arcs() const { return !arcs_.empty() ? &arcs_[0] : nullptr; } + + Arc *MutableArcs() { return !arcs_.empty() ? &arcs_[0] : nullptr; } + + void ReserveArcs(size_t n) { arcs_.reserve(n); } + + void SetFinal(Weight weight) { final_ = std::move(weight); } + + void SetNumInputEpsilons(size_t n) { niepsilons_ = n; } + + void SetNumOutputEpsilons(size_t n) { noepsilons_ = n; } + + void AddArc(const Arc &arc) { + if (arc.ilabel == 0) ++niepsilons_; + if (arc.olabel == 0) ++noepsilons_; + arcs_.push_back(arc); + } + + void SetArc(const Arc &arc, size_t n) { + if (arcs_[n].ilabel == 0) --niepsilons_; + if (arcs_[n].olabel == 0) --noepsilons_; + if (arc.ilabel == 0) ++niepsilons_; + if (arc.olabel == 0) ++noepsilons_; + arcs_[n] = arc; + } + + void DeleteArcs() { + niepsilons_ = 0; + noepsilons_ = 0; + arcs_.clear(); + } + + void DeleteArcs(size_t n) { + for (size_t i = 0; i < n; ++i) { + if (arcs_.back().ilabel == 0) --niepsilons_; + if (arcs_.back().olabel == 0) --noepsilons_; + arcs_.pop_back(); + } + } + + // For state class allocation. + void *operator new(size_t size, StateAllocator *alloc) { + return alloc->allocate(1); + } + + // For state destruction and memory freeing. + static void Destroy(VectorState *state, StateAllocator *alloc) { + if (state) { + state->~VectorState(); + alloc->deallocate(state, 1); + } + } + + private: + Weight final_; // Final weight. + size_t niepsilons_; // # of input epsilons + size_t noepsilons_; // # of output epsilons + std::vector arcs_; // Arc container. +}; + +namespace internal { + +// States are implemented by STL vectors, templated on the +// State definition. This does not manage the Fst properties. +template +class VectorFstBaseImpl : public FstImpl { + public: + using State = S; + using Arc = typename State::Arc; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + VectorFstBaseImpl() : start_(kNoStateId) {} + + ~VectorFstBaseImpl() override { + for (StateId s = 0; s < states_.size(); ++s) { + State::Destroy(states_[s], &state_alloc_); + } + } + + StateId Start() const { return start_; } + + Weight Final(StateId state) const { return states_[state]->Final(); } + + StateId NumStates() const { return states_.size(); } + + size_t NumArcs(StateId state) const { return states_[state]->NumArcs(); } + + size_t NumInputEpsilons(StateId state) const { + return GetState(state)->NumInputEpsilons(); + } + + size_t NumOutputEpsilons(StateId state) const { + return GetState(state)->NumOutputEpsilons(); + } + + void SetStart(StateId state) { start_ = state; } + + void SetFinal(StateId state, Weight weight) { + states_[state]->SetFinal(std::move(weight)); + } + + StateId AddState() { + states_.push_back(new (&state_alloc_) State(arc_alloc_)); + return states_.size() - 1; + } + + StateId AddState(State *state) { + states_.push_back(state); + return states_.size() - 1; + } + + void AddArc(StateId state, const Arc &arc) { states_[state]->AddArc(arc); } + + void DeleteStates(const std::vector &dstates) { + std::vector newid(states_.size(), 0); + for (StateId i = 0; i < dstates.size(); ++i) newid[dstates[i]] = kNoStateId; + StateId nstates = 0; + for (StateId state = 0; state < states_.size(); ++state) { + if (newid[state] != kNoStateId) { + newid[state] = nstates; + if (state != nstates) states_[nstates] = states_[state]; + ++nstates; + } else { + State::Destroy(states_[state], &state_alloc_); + } + } + states_.resize(nstates); + for (StateId state = 0; state < states_.size(); ++state) { + auto *arcs = states_[state]->MutableArcs(); + size_t narcs = 0; + auto nieps = states_[state]->NumInputEpsilons(); + auto noeps = states_[state]->NumOutputEpsilons(); + for (size_t i = 0; i < states_[state]->NumArcs(); ++i) { + const auto t = newid[arcs[i].nextstate]; + if (t != kNoStateId) { + arcs[i].nextstate = t; + if (i != narcs) arcs[narcs] = arcs[i]; + ++narcs; + } else { + if (arcs[i].ilabel == 0) --nieps; + if (arcs[i].olabel == 0) --noeps; + } + } + states_[state]->DeleteArcs(states_[state]->NumArcs() - narcs); + states_[state]->SetNumInputEpsilons(nieps); + states_[state]->SetNumOutputEpsilons(noeps); + } + if (Start() != kNoStateId) SetStart(newid[Start()]); + } + + void DeleteStates() { + for (StateId state = 0; state < states_.size(); ++state) { + State::Destroy(states_[state], &state_alloc_); + } + states_.clear(); + SetStart(kNoStateId); + } + + void DeleteArcs(StateId state, size_t n) { states_[state]->DeleteArcs(n); } + + void DeleteArcs(StateId state) { states_[state]->DeleteArcs(); } + + State *GetState(StateId state) { return states_[state]; } + + const State *GetState(StateId state) const { return states_[state]; } + + void SetState(StateId state, State *vstate) { states_[state] = vstate; } + + void ReserveStates(StateId n) { states_.reserve(n); } + + void ReserveArcs(StateId state, size_t n) { states_[state]->ReserveArcs(n); } + + // Provide information needed for generic state iterator. + void InitStateIterator(StateIteratorData *data) const { + data->base = nullptr; + data->nstates = states_.size(); + } + + // Provide information needed for generic arc iterator. + void InitArcIterator(StateId state, ArcIteratorData *data) const { + data->base = nullptr; + data->narcs = states_[state]->NumArcs(); + data->arcs = states_[state]->Arcs(); + data->ref_count = nullptr; + } + + private: + std::vector states_; // States represenation. + StateId start_; // Initial state. + typename State::StateAllocator state_alloc_; // For state allocation. + typename State::ArcAllocator arc_alloc_; // For arc allocation. + + VectorFstBaseImpl(const VectorFstBaseImpl &) = delete; + VectorFstBaseImpl &operator=(const VectorFstBaseImpl &) = delete; +}; + +// This is a VectorFstBaseImpl container that holds VectorStates and manages FST +// properties. +template +class VectorFstImpl : public VectorFstBaseImpl { + public: + using State = S; + using Arc = typename State::Arc; + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + using FstImpl::SetInputSymbols; + using FstImpl::SetOutputSymbols; + using FstImpl::SetType; + using FstImpl::SetProperties; + using FstImpl::Properties; + + using VectorFstBaseImpl::Start; + using VectorFstBaseImpl::NumStates; + using VectorFstBaseImpl::GetState; + using VectorFstBaseImpl::ReserveArcs; + + friend class MutableArcIterator>; + + using BaseImpl = VectorFstBaseImpl; + + VectorFstImpl() { + SetType("vector"); + SetProperties(kNullProperties | kStaticProperties); + } + + explicit VectorFstImpl(const Fst &fst); + + static VectorFstImpl *Read(std::istream &strm, const FstReadOptions &opts); + + void SetStart(StateId state) { + BaseImpl::SetStart(state); + SetProperties(SetStartProperties(Properties())); + } + + void SetFinal(StateId state, Weight weight) { + const auto old_weight = BaseImpl::Final(state); + const auto properties = + SetFinalProperties(Properties(), old_weight, weight); + BaseImpl::SetFinal(state, std::move(weight)); + SetProperties(properties); + } + + StateId AddState() { + const auto state = BaseImpl::AddState(); + SetProperties(AddStateProperties(Properties())); + return state; + } + + void AddArc(StateId state, const Arc &arc) { + auto *vstate = GetState(state); + const auto *parc = vstate->NumArcs() == 0 + ? nullptr + : &(vstate->GetArc(vstate->NumArcs() - 1)); + SetProperties(AddArcProperties(Properties(), state, arc, parc)); + BaseImpl::AddArc(state, arc); + } + + void DeleteStates(const std::vector &dstates) { + BaseImpl::DeleteStates(dstates); + SetProperties(DeleteStatesProperties(Properties())); + } + + void DeleteStates() { + BaseImpl::DeleteStates(); + SetProperties(DeleteAllStatesProperties(Properties(), kStaticProperties)); + } + + void DeleteArcs(StateId state, size_t n) { + BaseImpl::DeleteArcs(state, n); + SetProperties(DeleteArcsProperties(Properties())); + } + + void DeleteArcs(StateId state) { + BaseImpl::DeleteArcs(state); + SetProperties(DeleteArcsProperties(Properties())); + } + + // Properties always true of this FST class + static constexpr uint64 kStaticProperties = kExpanded | kMutable; + + private: + // Minimum file format version supported. + static constexpr int kMinFileVersion = 2; +}; + +template +constexpr uint64 VectorFstImpl::kStaticProperties; + +template +constexpr int VectorFstImpl::kMinFileVersion; + +template +VectorFstImpl::VectorFstImpl(const Fst &fst) { + SetType("vector"); + SetInputSymbols(fst.InputSymbols()); + SetOutputSymbols(fst.OutputSymbols()); + BaseImpl::SetStart(fst.Start()); + if (fst.Properties(kExpanded, false)) { + BaseImpl::ReserveStates(CountStates(fst)); + } + for (StateIterator> siter(fst); !siter.Done(); siter.Next()) { + const auto state = siter.Value(); + BaseImpl::AddState(); + BaseImpl::SetFinal(state, fst.Final(state)); + ReserveArcs(state, fst.NumArcs(state)); + for (ArcIterator> aiter(fst, state); !aiter.Done(); aiter.Next()) { + const auto &arc = aiter.Value(); + BaseImpl::AddArc(state, arc); + } + } + SetProperties(fst.Properties(kCopyProperties, false) | kStaticProperties); +} + +template +VectorFstImpl *VectorFstImpl::Read(std::istream &strm, + const FstReadOptions &opts) { + std::unique_ptr> impl(new VectorFstImpl()); + FstHeader hdr; + if (!impl->ReadHeader(strm, opts, kMinFileVersion, &hdr)) return nullptr; + impl->BaseImpl::SetStart(hdr.Start()); + if (hdr.NumStates() != kNoStateId) impl->ReserveStates(hdr.NumStates()); + StateId state = 0; + for (; hdr.NumStates() == kNoStateId || state < hdr.NumStates(); ++state) { + Weight weight; + if (!weight.Read(strm)) break; + impl->BaseImpl::AddState(); + auto *vstate = impl->GetState(state); + vstate->SetFinal(weight); + int64 narcs; + ReadType(strm, &narcs); + if (!strm) { + LOG(ERROR) << "VectorFst::Read: Read failed: " << opts.source; + return nullptr; + } + impl->ReserveArcs(state, narcs); + for (int64 i = 0; i < narcs; ++i) { + Arc arc; + ReadType(strm, &arc.ilabel); + ReadType(strm, &arc.olabel); + arc.weight.Read(strm); + ReadType(strm, &arc.nextstate); + if (!strm) { + LOG(ERROR) << "VectorFst::Read: Read failed: " << opts.source; + return nullptr; + } + impl->BaseImpl::AddArc(state, arc); + } + } + if (hdr.NumStates() != kNoStateId && state != hdr.NumStates()) { + LOG(ERROR) << "VectorFst::Read: Unexpected end of file: " << opts.source; + return nullptr; + } + return impl.release(); +} + +} // namespace internal + +// Simple concrete, mutable FST. This class attaches interface to implementation +// and handles reference counting, delegating most methods to ImplToMutableFst. +// Also supports ReserveStates and ReserveArcs methods (cf. STL vector methods). +// The second optional template argument gives the State definition. +template */> +class VectorFst : public ImplToMutableFst> { + public: + using Arc = A; + using StateId = typename Arc::StateId; + + using State = S; + using Impl = internal::VectorFstImpl; + + friend class StateIterator>; + friend class ArcIterator>; + friend class MutableArcIterator>; + + template + friend void Cast(const F &, G *); + + VectorFst() : ImplToMutableFst(std::make_shared()) {} + + explicit VectorFst(const Fst &fst) + : ImplToMutableFst(std::make_shared(fst)) {} + + VectorFst(const VectorFst &fst, bool safe = false) + : ImplToMutableFst(fst) {} + + // Get a copy of this VectorFst. See Fst<>::Copy() for further doc. + VectorFst *Copy(bool safe = false) const override { + return new VectorFst(*this, safe); + } + + VectorFst &operator=(const VectorFst &fst) { + SetImpl(fst.GetSharedImpl()); + return *this; + } + + VectorFst &operator=(const Fst &fst) override { + if (this != &fst) SetImpl(std::make_shared(fst)); + return *this; + } + + // Reads a VectorFst from an input stream, returning nullptr on error. + static VectorFst *Read(std::istream &strm, + const FstReadOptions &opts) { + auto *impl = Impl::Read(strm, opts); + return impl ? new VectorFst(std::shared_ptr(impl)) + : nullptr; + } + + // Read a VectorFst from a file, returning nullptr on error; empty filename + // reads from standard input. + static VectorFst *Read(const string &filename) { + auto *impl = ImplToExpandedFst>::Read(filename); + return impl ? new VectorFst(std::shared_ptr(impl)) + : nullptr; + } + + bool Write(std::ostream &strm, const FstWriteOptions &opts) const override { + return WriteFst(*this, strm, opts); + } + + bool Write(const string &filename) const override { + return Fst::WriteFile(filename); + } + + template + static bool WriteFst(const FST &fst, std::ostream &strm, + const FstWriteOptions &opts); + + void InitStateIterator(StateIteratorData *data) const override { + GetImpl()->InitStateIterator(data); + } + + void InitArcIterator(StateId s, ArcIteratorData *data) const override { + GetImpl()->InitArcIterator(s, data); + } + + inline void InitMutableArcIterator(StateId s, + MutableArcIteratorData *) override; + + using ImplToMutableFst>::ReserveArcs; + using ImplToMutableFst>::ReserveStates; + + private: + using ImplToMutableFst>::GetImpl; + using ImplToMutableFst>::MutateCheck; + using ImplToMutableFst>::SetImpl; + + explicit VectorFst(std::shared_ptr impl) + : ImplToMutableFst(impl) {} +}; + +// Writes FST to file in Vector format, potentially with a pass over the machine +// before writing to compute number of states. +template +template +bool VectorFst::WriteFst(const FST &fst, std::ostream &strm, + const FstWriteOptions &opts) { + static constexpr int file_version = 2; + bool update_header = true; + FstHeader hdr; + hdr.SetStart(fst.Start()); + hdr.SetNumStates(kNoStateId); + size_t start_offset = 0; + if (fst.Properties(kExpanded, false) || opts.stream_write || + (start_offset = strm.tellp()) != -1) { + hdr.SetNumStates(CountStates(fst)); + update_header = false; + } + const auto properties = + fst.Properties(kCopyProperties, false) | Impl::kStaticProperties; + internal::FstImpl::WriteFstHeader(fst, strm, opts, file_version, + "vector", properties, &hdr); + StateId num_states = 0; + for (StateIterator siter(fst); !siter.Done(); siter.Next()) { + const auto s = siter.Value(); + fst.Final(s).Write(strm); + const int64 narcs = fst.NumArcs(s); + WriteType(strm, narcs); + for (ArcIterator aiter(fst, s); !aiter.Done(); aiter.Next()) { + const auto &arc = aiter.Value(); + WriteType(strm, arc.ilabel); + WriteType(strm, arc.olabel); + arc.weight.Write(strm); + WriteType(strm, arc.nextstate); + } + ++num_states; + } + strm.flush(); + if (!strm) { + LOG(ERROR) << "VectorFst::Write: Write failed: " << opts.source; + return false; + } + if (update_header) { + hdr.SetNumStates(num_states); + return internal::FstImpl::UpdateFstHeader( + fst, strm, opts, file_version, "vector", properties, &hdr, + start_offset); + } else { + if (num_states != hdr.NumStates()) { + LOG(ERROR) << "Inconsistent number of states observed during write"; + return false; + } + } + return true; +} + +// Specialization for VectorFst; see generic version in fst.h for sample usage +// (but use the VectorFst type instead). This version should inline. +template +class StateIterator> { + public: + using StateId = typename Arc::StateId; + + explicit StateIterator(const VectorFst &fst) + : nstates_(fst.GetImpl()->NumStates()), s_(0) {} + + bool Done() const { return s_ >= nstates_; } + + StateId Value() const { return s_; } + + void Next() { ++s_; } + + void Reset() { s_ = 0; } + + private: + const StateId nstates_; + StateId s_; +}; + +// Specialization for VectorFst; see generic version in fst.h for sample usage +// (but use the VectorFst type instead). This version should inline. +template +class ArcIterator> { + public: + using StateId = typename Arc::StateId; + + ArcIterator(const VectorFst &fst, StateId s) + : arcs_(fst.GetImpl()->GetState(s)->Arcs()), + narcs_(fst.GetImpl()->GetState(s)->NumArcs()), + i_(0) {} + + bool Done() const { return i_ >= narcs_; } + + const Arc &Value() const { return arcs_[i_]; } + + void Next() { ++i_; } + + void Reset() { i_ = 0; } + + void Seek(size_t a) { i_ = a; } + + size_t Position() const { return i_; } + + constexpr uint32 Flags() const { return kArcValueFlags; } + + void SetFlags(uint32, uint32) {} + + private: + const Arc *arcs_; + size_t narcs_; + size_t i_; +}; + +// Specialization for VectorFst; see generic version in mutable-fst.h for sample +// usage (but use the VectorFst type instead). This version should inline. +template +class MutableArcIterator> + : public MutableArcIteratorBase { + public: + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + + MutableArcIterator(VectorFst *fst, StateId s) : i_(0) { + fst->MutateCheck(); + state_ = fst->GetMutableImpl()->GetState(s); + properties_ = &fst->GetImpl()->properties_; + } + + bool Done() const final { return i_ >= state_->NumArcs(); } + + const Arc &Value() const final { return state_->GetArc(i_); } + + void Next() final { ++i_; } + + size_t Position() const final { return i_; } + + void Reset() final { i_ = 0; } + + void Seek(size_t a) final { i_ = a; } + + void SetValue(const Arc &arc) final { + const auto &oarc = state_->GetArc(i_); + if (oarc.ilabel != oarc.olabel) *properties_ &= ~kNotAcceptor; + if (oarc.ilabel == 0) { + *properties_ &= ~kIEpsilons; + if (oarc.olabel == 0) *properties_ &= ~kEpsilons; + } + if (oarc.olabel == 0) *properties_ &= ~kOEpsilons; + if (oarc.weight != Weight::Zero() && oarc.weight != Weight::One()) { + *properties_ &= ~kWeighted; + } + state_->SetArc(arc, i_); + if (arc.ilabel != arc.olabel) { + *properties_ |= kNotAcceptor; + *properties_ &= ~kAcceptor; + } + if (arc.ilabel == 0) { + *properties_ |= kIEpsilons; + *properties_ &= ~kNoIEpsilons; + if (arc.olabel == 0) { + *properties_ |= kEpsilons; + *properties_ &= ~kNoEpsilons; + } + } + if (arc.olabel == 0) { + *properties_ |= kOEpsilons; + *properties_ &= ~kNoOEpsilons; + } + if (arc.weight != Weight::Zero() && arc.weight != Weight::One()) { + *properties_ |= kWeighted; + *properties_ &= ~kUnweighted; + } + *properties_ &= kSetArcProperties | kAcceptor | kNotAcceptor | kEpsilons | + kNoEpsilons | kIEpsilons | kNoIEpsilons | kOEpsilons | + kNoOEpsilons | kWeighted | kUnweighted; + } + + uint32 Flags() const final { return kArcValueFlags; } + + void SetFlags(uint32, uint32) final {} + + private: + State *state_; + uint64 *properties_; + size_t i_; +}; + +// Provides information needed for the generic mutable arc iterator. +template +inline void VectorFst::InitMutableArcIterator( + StateId s, MutableArcIteratorData *data) { + data->base = new MutableArcIterator>(this, s); +} + +// A useful alias when using StdArc. +using StdVectorFst = VectorFst; + +} // namespace fst + +#endif // FST_VECTOR_FST_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/verify.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/verify.h new file mode 100644 index 0000000000..69837441c9 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/verify.h @@ -0,0 +1,102 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Function to verify an FST's contents. + +#ifndef FST_VERIFY_H_ +#define FST_VERIFY_H_ + +#include + +#include +#include + + +namespace fst { + +// Verifies that an Fst's contents are sane. +template +bool Verify(const Fst &fst, bool allow_negative_labels = false) { + using Label = typename Arc::Label; + using StateId = typename Arc::StateId; + using Weight = typename Arc::Weight; + const auto start = fst.Start(); + const auto *isyms = fst.InputSymbols(); + const auto *osyms = fst.OutputSymbols(); + // Count states + StateId ns = 0; + for (StateIterator> siter(fst); !siter.Done(); siter.Next()) ++ns; + if (start == kNoStateId && ns > 0) { + LOG(ERROR) << "Verify: FST start state ID not set"; + return false; + } else if (start >= ns) { + LOG(ERROR) << "Verify: FST start state ID exceeds number of states"; + return false; + } + for (StateIterator> siter(fst); !siter.Done(); siter.Next()) { + auto state = siter.Value(); + size_t na = 0; + for (ArcIterator> aiter(fst, state); !aiter.Done(); aiter.Next()) { + const auto &arc = aiter.Value(); + if (!allow_negative_labels && arc.ilabel < 0) { + LOG(ERROR) << "Verify: FST input label ID of arc at position " << na + << " of state " << state << " is negative"; + return false; + } else if (isyms && isyms->Find(arc.ilabel) == "") { + LOG(ERROR) << "Verify: FST input label ID " << arc.ilabel + << " of arc at position " << na << " of state " << state + << " is missing from input symbol table \"" << isyms->Name() + << "\""; + return false; + } else if (!allow_negative_labels && arc.olabel < 0) { + LOG(ERROR) << "Verify: FST output label ID of arc at position " << na + << " of state " << state << " is negative"; + return false; + } else if (osyms && osyms->Find(arc.olabel) == "") { + LOG(ERROR) << "Verify: FST output label ID " << arc.olabel + << " of arc at position " << na << " of state " << state + << " is missing from output symbol table \"" << osyms->Name() + << "\""; + return false; + } else if (!arc.weight.Member()) { + LOG(ERROR) << "Verify: FST weight of arc at position " << na + << " of state " << state << " is invalid"; + return false; + } else if (arc.nextstate < 0) { + LOG(ERROR) << "Verify: FST destination state ID of arc at position " + << na << " of state " << state << " is negative"; + return false; + } else if (arc.nextstate >= ns) { + LOG(ERROR) << "Verify: FST destination state ID of arc at position " + << na << " of state " << state + << " exceeds number of states"; + return false; + } + ++na; + } + if (!fst.Final(state).Member()) { + LOG(ERROR) << "Verify: FST final weight of state " << state + << " is invalid"; + return false; + } + } + const auto fst_props = fst.Properties(kFstProperties, false); + if (fst_props & kError) { + LOG(ERROR) << "Verify: FST error property is set"; + return false; + } + uint64 known_props; + uint64 test_props = + ComputeProperties(fst, kFstProperties, &known_props, false); + if (!CompatProperties(fst_props, test_props)) { + LOG(ERROR) << "Verify: Stored FST properties incorrect " + << "(props1 = stored props, props2 = tested)"; + return false; + } else { + return true; + } +} + +} // namespace fst + +#endif // FST_VERIFY_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/visit.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/visit.h new file mode 100644 index 0000000000..c665804792 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/visit.h @@ -0,0 +1,321 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Queue-dependent visitation of finite-state transducers. See also dfs-visit.h. + +#ifndef FST_VISIT_H_ +#define FST_VISIT_H_ + + +#include +#include + + +namespace fst { + +// Visitor Interface: class determining actions taken during a visit. If any of +// the boolean member functions return false, the visit is aborted by first +// calling FinishState() on all unfinished (grey) states and then calling +// FinishVisit(). +// +// Note this is more general than the visitor interface in dfs-visit.h but lacks +// some DFS-specific behavior. +// +// template +// class Visitor { +// public: +// using StateId = typename Arc::StateId; +// +// Visitor(T *return_data); +// +// // Invoked before visit. +// void InitVisit(const Fst &fst); +// +// // Invoked when state discovered (2nd arg is visitation root). +// bool InitState(StateId s, StateId root); +// +// // Invoked when arc to white/undiscovered state examined. +// bool WhiteArc(StateId s, const Arc &arc); +// +// // Invoked when arc to grey/unfinished state examined. +// bool GreyArc(StateId s, const Arc &arc); +// +// // Invoked when arc to black/finished state examined. +// bool BlackArc(StateId s, const Arc &arc); +// +// // Invoked when state finished. +// void FinishState(StateId s); +// +// // Invoked after visit. +// void FinishVisit(); +// }; + +// Performs queue-dependent visitation. Visitor class argument determines +// actions and contains any return data. ArcFilter determines arcs that are +// considered. If 'access_only' is true, performs visitation only to states +// accessible from the initial state. +template +void Visit(const FST &fst, Visitor *visitor, Queue *queue, ArcFilter filter, + bool access_only = false) { + using Arc = typename FST::Arc; + using StateId = typename Arc::StateId; + visitor->InitVisit(fst); + const auto start = fst.Start(); + if (start == kNoStateId) { + visitor->FinishVisit(); + return; + } + // An FST's state's visit color. + static constexpr uint8 kWhiteState = 0x01; // Undiscovered. + static constexpr uint8 kGreyState = 0x02; // Discovered & unfinished. + static constexpr uint8 kBlackState = 0x04; // Finished. + // We destroy an iterator as soon as possible and mark it so. + static constexpr uint8 kArcIterDone = 0x08; + std::vector state_status; + std::vector *> arc_iterator; + MemoryPool> aiter_pool; + StateId nstates = start + 1; // Number of known states in general case. + bool expanded = false; + if (fst.Properties(kExpanded, false)) { // Tests if expanded, then uses + nstates = CountStates(fst); // ExpandedFst::NumStates(). + expanded = true; + } + state_status.resize(nstates, kWhiteState); + arc_iterator.resize(nstates); + StateIterator> siter(fst); + // Continues visit while true. + bool visit = true; + // Iterates over trees in visit forest. + for (auto root = start; visit && root < nstates;) { + visit = visitor->InitState(root, root); + state_status[root] = kGreyState; + queue->Enqueue(root); + while (!queue->Empty()) { + auto state = queue->Head(); + if (state >= state_status.size()) { + nstates = state + 1; + state_status.resize(nstates, kWhiteState); + arc_iterator.resize(nstates); + } + // Creates arc iterator if needed. + if (!arc_iterator[state] && !(state_status[state] & kArcIterDone) && + visit) { + arc_iterator[state] = new (&aiter_pool) ArcIterator(fst, state); + } + // Deletes arc iterator if done. + auto *aiter = arc_iterator[state]; + if ((aiter && aiter->Done()) || !visit) { + Destroy(aiter, &aiter_pool); + arc_iterator[state] = nullptr; + state_status[state] |= kArcIterDone; + } + // Dequeues state and marks black if done. + if (state_status[state] & kArcIterDone) { + queue->Dequeue(); + visitor->FinishState(state); + state_status[state] = kBlackState; + continue; + } + const auto &arc = aiter->Value(); + if (arc.nextstate >= state_status.size()) { + nstates = arc.nextstate + 1; + state_status.resize(nstates, kWhiteState); + arc_iterator.resize(nstates); + } + // Visits respective arc types. + if (filter(arc)) { + // Enqueues destination state and marks grey if white. + if (state_status[arc.nextstate] == kWhiteState) { + visit = visitor->WhiteArc(state, arc); + if (!visit) continue; + visit = visitor->InitState(arc.nextstate, root); + state_status[arc.nextstate] = kGreyState; + queue->Enqueue(arc.nextstate); + } else if (state_status[arc.nextstate] == kBlackState) { + visit = visitor->BlackArc(state, arc); + } else { + visit = visitor->GreyArc(state, arc); + } + } + aiter->Next(); + // Destroys an iterator ASAP for efficiency. + if (aiter->Done()) { + Destroy(aiter, &aiter_pool); + arc_iterator[state] = nullptr; + state_status[state] |= kArcIterDone; + } + } + if (access_only) break; + // Finds next tree root. + for (root = (root == start) ? 0 : root + 1; + root < nstates && state_status[root] != kWhiteState; ++root) { + } + // Check for a state beyond the largest known state. + if (!expanded && root == nstates) { + for (; !siter.Done(); siter.Next()) { + if (siter.Value() == nstates) { + ++nstates; + state_status.push_back(kWhiteState); + arc_iterator.push_back(nullptr); + break; + } + } + } + } + visitor->FinishVisit(); +} + +template +inline void Visit(const Fst &fst, Visitor *visitor, Queue *queue) { + Visit(fst, visitor, queue, AnyArcFilter()); +} + +// Copies input FST to mutable FST following queue order. +template +class CopyVisitor { + public: + using Arc = A; + using StateId = typename Arc::StateId; + + explicit CopyVisitor(MutableFst *ofst) : ifst_(nullptr), ofst_(ofst) {} + + void InitVisit(const Fst &ifst) { + ifst_ = &ifst; + ofst_->DeleteStates(); + ofst_->SetStart(ifst_->Start()); + } + + bool InitState(StateId state, StateId) { + while (ofst_->NumStates() <= state) ofst_->AddState(); + return true; + } + + bool WhiteArc(StateId state, const Arc &arc) { + ofst_->AddArc(state, arc); + return true; + } + + bool GreyArc(StateId state, const Arc &arc) { + ofst_->AddArc(state, arc); + return true; + } + + bool BlackArc(StateId state, const Arc &arc) { + ofst_->AddArc(state, arc); + return true; + } + + void FinishState(StateId state) { + ofst_->SetFinal(state, ifst_->Final(state)); + } + + void FinishVisit() {} + + private: + const Fst *ifst_; + MutableFst *ofst_; +}; + +// Visits input FST up to a state limit following queue order. +template +class PartialVisitor { + public: + using Arc = A; + using StateId = typename Arc::StateId; + + explicit PartialVisitor(StateId maxvisit) + : fst_(nullptr), maxvisit_(maxvisit) {} + + void InitVisit(const Fst &ifst) { + fst_ = &ifst; + ninit_ = 0; + nfinish_ = 0; + } + + bool InitState(StateId state, StateId root) { + ++ninit_; + return ninit_ <= maxvisit_; + } + + bool WhiteArc(StateId state, const Arc &arc) { return true; } + + bool GreyArc(StateId state, const Arc &arc) { return true; } + + bool BlackArc(StateId state, const Arc &arc) { return true; } + + void FinishState(StateId state) { + fst_->Final(state); // Visits super-final arc. + ++nfinish_; + } + + void FinishVisit() {} + + StateId NumInitialized() { return ninit_; } + + StateId NumFinished() { return nfinish_; } + + private: + const Fst *fst_; + StateId maxvisit_; + StateId ninit_; + StateId nfinish_; +}; + +// Copies input FST to mutable FST up to a state limit following queue order. +template +class PartialCopyVisitor : public CopyVisitor { + public: + using Arc = A; + using StateId = typename Arc::StateId; + + using CopyVisitor::WhiteArc; + + PartialCopyVisitor(MutableFst *ofst, StateId maxvisit, + bool copy_grey = true, bool copy_black = true) + : CopyVisitor(ofst), maxvisit_(maxvisit), + copy_grey_(copy_grey), copy_black_(copy_black) {} + + void InitVisit(const Fst &ifst) { + CopyVisitor::InitVisit(ifst); + ninit_ = 0; + nfinish_ = 0; + } + + bool InitState(StateId state, StateId root) { + CopyVisitor::InitState(state, root); + ++ninit_; + return ninit_ <= maxvisit_; + } + + bool GreyArc(StateId state, const Arc &arc) { + if (copy_grey_) return CopyVisitor::GreyArc(state, arc); + return true; + } + + bool BlackArc(StateId state, const Arc &arc) { + if (copy_black_) return CopyVisitor::BlackArc(state, arc); + return true; + } + + void FinishState(StateId state) { + CopyVisitor::FinishState(state); + ++nfinish_; + } + + void FinishVisit() {} + + StateId NumInitialized() { return ninit_; } + + StateId NumFinished() { return nfinish_; } + + private: + StateId maxvisit_; + StateId ninit_; + StateId nfinish_; + const bool copy_grey_; + const bool copy_black_; +}; + +} // namespace fst + +#endif // FST_VISIT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/weight.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/weight.h new file mode 100644 index 0000000000..722d63ad54 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/include/fst/weight.h @@ -0,0 +1,380 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// General weight set and associated semiring operation definitions. + +#ifndef FST_WEIGHT_H_ +#define FST_WEIGHT_H_ + +#include +#include +#include +#include +#include +#include + +#include +#include + +#include + + +DECLARE_string(fst_weight_parentheses); +DECLARE_string(fst_weight_separator); + +namespace fst { + +// A semiring is specified by two binary operations Plus and Times and two +// designated elements Zero and One with the following properties: +// +// Plus: associative, commutative, and has Zero as its identity. +// +// Times: associative and has identity One, distributes w.r.t. Plus, and +// has Zero as an annihilator: +// Times(Zero(), a) == Times(a, Zero()) = Zero(). +// +// A left semiring distributes on the left; a right semiring is similarly +// defined. +// +// A Weight class must have binary functions Plus and Times and static member +// functions Zero() and One() and these must form (at least) a left or right +// semiring. +// +// In addition, the following should be defined for a Weight: +// +// Member: predicate on set membership. +// +// NoWeight: static member function that returns an element that is +// not a set member; used to signal an error. +// +// >>: reads textual representation of a weight. +// +// <<: prints textual representation of a weight. +// +// Read(istream &istrm): reads binary representation of a weight. +// +// Write(ostream &ostrm): writes binary representation of a weight. +// +// Hash: maps weight to size_t. +// +// ApproxEqual: approximate equality (for inexact weights) +// +// Quantize: quantizes w.r.t delta (for inexact weights) +// +// Divide: for all a, b, c s.t. Times(a, b) == c +// +// --> b' = Divide(c, a, DIVIDE_LEFT) if a left semiring, b'.Member() +// and Times(a, b') == c +// --> a' = Divide(c, b, DIVIDE_RIGHT) if a right semiring, a'.Member() +// and Times(a', b) == c +// --> b' = Divide(c, a) = Divide(c, a, DIVIDE_ANY) = +// Divide(c, a, DIVIDE_LEFT) = Divide(c, a, DIVIDE_RIGHT) if a +// commutative semiring, b'.Member() and Times(a, b') = Times(b', a) = c +// +// ReverseWeight: the type of the corresponding reverse weight. +// +// Typically the same type as Weight for a (both left and right) semiring. +// For the left string semiring, it is the right string semiring. +// +// Reverse: a mapping from Weight to ReverseWeight s.t. +// +// --> Reverse(Reverse(a)) = a +// --> Reverse(Plus(a, b)) = Plus(Reverse(a), Reverse(b)) +// --> Reverse(Times(a, b)) = Times(Reverse(b), Reverse(a)) +// Typically the identity mapping in a (both left and right) semiring. +// In the left string semiring, it maps to the reverse string in the right +// string semiring. +// +// Properties: specifies additional properties that hold: +// LeftSemiring: indicates weights form a left semiring. +// RightSemiring: indicates weights form a right semiring. +// Commutative: for all a,b: Times(a,b) == Times(b,a) +// Idempotent: for all a: Plus(a, a) == a. +// Path: for all a, b: Plus(a, b) == a or Plus(a, b) == b. + +// CONSTANT DEFINITIONS + +// A representable float near .001. +constexpr float kDelta = 1.0F / 1024.0F; + +// For all a, b, c: Times(c, Plus(a, b)) = Plus(Times(c, a), Times(c, b)). +constexpr uint64 kLeftSemiring = 0x0000000000000001ULL; + +// For all a, b, c: Times(Plus(a, b), c) = Plus(Times(a, c), Times(b, c)). +constexpr uint64 kRightSemiring = 0x0000000000000002ULL; + +constexpr uint64 kSemiring = kLeftSemiring | kRightSemiring; + +// For all a, b: Times(a, b) = Times(b, a). +constexpr uint64 kCommutative = 0x0000000000000004ULL; + +// For all a: Plus(a, a) = a. +constexpr uint64 kIdempotent = 0x0000000000000008ULL; + +// For all a, b: Plus(a, b) = a or Plus(a, b) = b. +constexpr uint64 kPath = 0x0000000000000010ULL; + +// For random weight generation: default number of distinct weights. +// This is also used for a few other weight generation defaults. +constexpr size_t kNumRandomWeights = 5; + +// Weight property boolean constants needed for SFINAE. + +template +using IsIdempotent = std::integral_constant; + +template +using IsPath = std::integral_constant; + +// Determines direction of division. +enum DivideType { + DIVIDE_LEFT, // left division + DIVIDE_RIGHT, // right division + DIVIDE_ANY +}; // division in a commutative semiring + +// NATURAL ORDER +// +// By definition: +// +// a <= b iff a + b = a +// +// The natural order is a negative partial order iff the semiring is +// idempotent. It is trivially monotonic for plus. It is left +// (resp. right) monotonic for times iff the semiring is left +// (resp. right) distributive. It is a total order iff the semiring +// has the path property. +// +// For more information, see: +// +// Mohri, M. 2002. Semiring framework and algorithms for shortest-distance +// problems, Journal of Automata, Languages and +// Combinatorics 7(3): 321-350, 2002. +// +// We define the strict version of this order below. + +// Declares the template with a second parameter determining whether or not it +// can actually be constructed. +template +class NaturalLess; + +// Variant for idempotent weights. +template +class NaturalLess::value>::type> { + public: + using Weight = W; + + NaturalLess() {} + + bool operator()(const Weight &w1, const Weight &w2) const { + return w1 != w2 && Plus(w1, w2) == w1; + } +}; + +// Non-constructible variant for non-idempotent weights. +template +class NaturalLess::value>::type> { + public: + using Weight = W; + + // TODO(kbg): Trace down anywhere this is being instantiated, then add a + // static_assert to prevent this from being instantiated. + NaturalLess() { + FSTERROR() << "NaturalLess: Weight type is not idempotent: " << W::Type(); + } + + bool operator()(const Weight &, const Weight &) const { return false; } +}; + +// Power is the iterated product for arbitrary semirings such that Power(w, 0) +// is One() for the semiring, and Power(w, n) = Times(Power(w, n - 1), w). +template +Weight Power(const Weight &weight, size_t n) { + auto result = Weight::One(); + for (size_t i = 0; i < n; ++i) result = Times(result, weight); + return result; +} + +// Simple default adder class. Specializations might be more complex. +template +class Adder { + public: + explicit Adder(Weight w = Weight::Zero()) : sum_(w) { } + + Weight Add(const Weight &w) { + sum_ = Plus(sum_, w); + return sum_; + } + + Weight Sum() { return sum_; } + + void Reset(Weight w = Weight::Zero()) { sum_ = w; } + + private: + Weight sum_; +}; + +// General weight converter: raises error. +template +struct WeightConvert { + W2 operator()(W1 w1) const { + FSTERROR() << "WeightConvert: Can't convert weight from \"" << W1::Type() + << "\" to \"" << W2::Type(); + return W2::NoWeight(); + } +}; + +// Specialized weight converter to self. +template +struct WeightConvert { + W operator()(W weight) const { return weight; } +}; + +// General random weight generator: raises error. +template +struct WeightGenerate { + W operator()() const { + FSTERROR() << "WeightGenerate: No random generator for " << W::Type(); + return W::NoWeight(); + } +}; + +namespace internal { + +class CompositeWeightIO { + public: + CompositeWeightIO(); + CompositeWeightIO(char separator, std::pair parentheses); + + std::pair parentheses() const { + return {open_paren_, close_paren_}; + } + char separator() const { return separator_; } + + bool error() const { return error_; } + + protected: + const char separator_; + const char open_paren_; + const char close_paren_; + + private: + bool error_; +}; + +} // namespace internal + +// Helper class for writing textual composite weights. +class CompositeWeightWriter : public internal::CompositeWeightIO { + public: + // Uses configuration from flags (FLAGS_fst_weight_separator, + // FLAGS_fst_weight_parentheses). + explicit CompositeWeightWriter(std::ostream &ostrm); + + // parentheses defines the opening and closing parenthesis characters. + // Set parentheses = {0, 0} to disable writing parenthesis. + CompositeWeightWriter(std::ostream &ostrm, char separator, + std::pair parentheses); + + CompositeWeightWriter(const CompositeWeightWriter &) = delete; + CompositeWeightWriter &operator=(const CompositeWeightWriter &) = delete; + + // Writes open parenthesis to a stream if option selected. + void WriteBegin(); + + // Writes element to a stream. + template + void WriteElement(const T &comp) { + if (i_++ > 0) ostrm_ << separator_; + ostrm_ << comp; + } + + // Writes close parenthesis to a stream if option selected. + void WriteEnd(); + + private: + std::ostream &ostrm_; + int i_ = 0; // Element position. +}; + +// Helper class for reading textual composite weights. Elements are separated by +// a separator character. There must be at least one element per textual +// representation. Parentheses characters should be set if the composite +// weights themselves contain composite weights to ensure proper parsing. +class CompositeWeightReader : public internal::CompositeWeightIO { + public: + // Uses configuration from flags (FLAGS_fst_weight_separator, + // FLAGS_fst_weight_parentheses). + explicit CompositeWeightReader(std::istream &istrm); + + // parentheses defines the opening and closing parenthesis characters. + // Set parentheses = {0, 0} to disable reading parenthesis. + CompositeWeightReader(std::istream &istrm, char separator, + std::pair parentheses); + + CompositeWeightReader(const CompositeWeightReader &) = delete; + CompositeWeightReader &operator=(const CompositeWeightReader &) = delete; + + // Reads open parenthesis from a stream if option selected. + void ReadBegin(); + + // Reads element from a stream. The second argument, when true, indicates that + // this will be the last element (allowing more forgiving formatting of the + // last element). Returns false when last element is read. + template + bool ReadElement(T *comp, bool last = false); + + // Finalizes reading. + void ReadEnd(); + + private: + std::istream &istrm_; // Input stream. + int c_ = 0; // Last character read, or EOF. + int depth_ = 0; // Weight parentheses depth. +}; + +template +inline bool CompositeWeightReader::ReadElement(T *comp, bool last) { + string s; + const bool has_parens = open_paren_ != 0; + while ((c_ != std::istream::traits_type::eof()) && !std::isspace(c_) && + (c_ != separator_ || depth_ > 1 || last) && + (c_ != close_paren_ || depth_ != 1)) { + s += c_; + // If parentheses encountered before separator, they must be matched. + if (has_parens && c_ == open_paren_) { + ++depth_; + } else if (has_parens && c_ == close_paren_) { + // Failure on unmatched parentheses. + if (depth_ == 0) { + FSTERROR() << "CompositeWeightReader: Unmatched close paren: " + << "Is the fst_weight_parentheses flag set correctly?"; + istrm_.clear(std::ios::badbit); + return false; + } + --depth_; + } + c_ = istrm_.get(); + } + if (s.empty()) { + FSTERROR() << "CompositeWeightReader: Empty element: " + << "Is the fst_weight_parentheses flag set correctly?"; + istrm_.clear(std::ios::badbit); + return false; + } + std::istringstream istrm(s); + istrm >> *comp; + // Skips separator/close parenthesis. + if (c_ != std::istream::traits_type::eof() && !std::isspace(c_)) { + c_ = istrm_.get(); + } + const bool is_eof = c_ == std::istream::traits_type::eof(); + // Clears fail bit if just EOF. + if (is_eof && !istrm_.bad()) istrm_.clear(std::ios::eofbit); + return !is_eof && !std::isspace(c_); +} + +} // namespace fst + +#endif // FST_WEIGHT_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/Makefile.am b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/Makefile.am new file mode 100644 index 0000000000..dea4f75cd1 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/Makefile.am @@ -0,0 +1,8 @@ +AM_CPPFLAGS = -I$(srcdir)/../include $(ICU_CPPFLAGS) + +lib_LTLIBRARIES = libfst.la +libfst_la_SOURCES = compat.cc flags.cc fst.cc fst-types.cc mapped-file.cc \ + properties.cc symbol-table.cc symbol-table-ops.cc \ + weight.cc util.cc +libfst_la_LDFLAGS = -version-info 10:0:0 +libfst_la_LIBADD = $(DL_LIBS) diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/Makefile.in b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/Makefile.in new file mode 100644 index 0000000000..5819dcdfd8 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/Makefile.in @@ -0,0 +1,671 @@ +# Makefile.in generated by automake 1.14.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2013 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +VPATH = @srcdir@ +am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +subdir = src/lib +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ + $(top_srcdir)/depcomp +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \ + $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ + $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ + $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h \ + $(top_builddir)/src/include/fst/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__uninstall_files_from_dir = { \ + test -z "$$files" \ + || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && rm -f $$files; }; \ + } +am__installdirs = "$(DESTDIR)$(libdir)" +LTLIBRARIES = $(lib_LTLIBRARIES) +am__DEPENDENCIES_1 = +libfst_la_DEPENDENCIES = $(am__DEPENDENCIES_1) +am_libfst_la_OBJECTS = compat.lo flags.lo fst.lo fst-types.lo \ + mapped-file.lo properties.lo symbol-table.lo \ + symbol-table-ops.lo weight.lo util.lo +libfst_la_OBJECTS = $(am_libfst_la_OBJECTS) +AM_V_lt = $(am__v_lt_@AM_V@) +am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) +am__v_lt_0 = --silent +am__v_lt_1 = +libfst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(libfst_la_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +DEFAULT_INCLUDES = +depcomp = $(SHELL) $(top_srcdir)/depcomp +am__depfiles_maybe = depfiles +am__mv = mv -f +CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CXXFLAGS) $(CXXFLAGS) +AM_V_CXX = $(am__v_CXX_@AM_V@) +am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@) +am__v_CXX_0 = @echo " CXX " $@; +am__v_CXX_1 = +CXXLD = $(CXX) +CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_CXXLD = $(am__v_CXXLD_@AM_V@) +am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@) +am__v_CXXLD_0 = @echo " CXXLD " $@; +am__v_CXXLD_1 = +SOURCES = $(libfst_la_SOURCES) +DIST_SOURCES = $(libfst_la_SOURCES) +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DL_LIBS = @DL_LIBS@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PYTHON = @PYTHON@ +PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@ +PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ +PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@ +PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@ +PYTHON_LDFLAGS = @PYTHON_LDFLAGS@ +PYTHON_PLATFORM = @PYTHON_PLATFORM@ +PYTHON_PREFIX = @PYTHON_PREFIX@ +PYTHON_SITE_PKG = @PYTHON_SITE_PKG@ +PYTHON_VERSION = @PYTHON_VERSION@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +libfstdir = @libfstdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgpyexecdir = @pkgpyexecdir@ +pkgpythondir = @pkgpythondir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +pyexecdir = @pyexecdir@ +pythondir = @pythondir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +AM_CPPFLAGS = -I$(srcdir)/../include $(ICU_CPPFLAGS) +lib_LTLIBRARIES = libfst.la +libfst_la_SOURCES = compat.cc flags.cc fst.cc fst-types.cc mapped-file.cc \ + properties.cc symbol-table.cc symbol-table-ops.cc \ + weight.cc util.cc + +libfst_la_LDFLAGS = -version-info 10:0:0 +libfst_la_LIBADD = $(DL_LIBS) +all: all-am + +.SUFFIXES: +.SUFFIXES: .cc .lo .o .obj +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/lib/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign src/lib/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +install-libLTLIBRARIES: $(lib_LTLIBRARIES) + @$(NORMAL_INSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \ + } + +uninstall-libLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \ + done + +clean-libLTLIBRARIES: + -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES) + @list='$(lib_LTLIBRARIES)'; \ + locs=`for p in $$list; do echo $$p; done | \ + sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ + sort -u`; \ + test -z "$$locs" || { \ + echo rm -f $${locs}; \ + rm -f $${locs}; \ + } + +libfst.la: $(libfst_la_OBJECTS) $(libfst_la_DEPENDENCIES) $(EXTRA_libfst_la_DEPENDENCIES) + $(AM_V_CXXLD)$(libfst_la_LINK) -rpath $(libdir) $(libfst_la_OBJECTS) $(libfst_la_LIBADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compat.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/flags.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fst-types.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fst.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mapped-file.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/properties.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/symbol-table-ops.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/symbol-table.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/util.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/weight.Plo@am__quote@ + +.cc.o: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $< + +.cc.obj: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cc.lo: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ +@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $< + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-am +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-am + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscopelist: cscopelist-am + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(LTLIBRARIES) +installdirs: + for dir in "$(DESTDIR)$(libdir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \ + mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: install-libLTLIBRARIES + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-libLTLIBRARIES + +.MAKE: install-am install-strip + +.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \ + clean-libLTLIBRARIES clean-libtool cscopelist-am ctags \ + ctags-am distclean distclean-compile distclean-generic \ + distclean-libtool distclean-tags distdir dvi dvi-am html \ + html-am info info-am install install-am install-data \ + install-data-am install-dvi install-dvi-am install-exec \ + install-exec-am install-html install-html-am install-info \ + install-info-am install-libLTLIBRARIES install-man install-pdf \ + install-pdf-am install-ps install-ps-am install-strip \ + installcheck installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-compile \ + mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ + tags tags-am uninstall uninstall-am uninstall-libLTLIBRARIES + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/compat.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/compat.cc new file mode 100644 index 0000000000..43dad4c17c --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/compat.cc @@ -0,0 +1,28 @@ +// compat.cc +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// Author: riley@google.com (Michael Riley) +// +// \file +// Google compatibility definitions. + +#include +#include + +using namespace std; + +void FailedNewHandler() { + cerr << "Memory allocation failed\n"; + exit(1); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/flags.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/flags.cc new file mode 100644 index 0000000000..498d3d6833 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/flags.cc @@ -0,0 +1,128 @@ +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// Google-style flag handling definitions. + +#include +#include + +static const char *private_tmpdir = getenv("TMPDIR"); + +DEFINE_int32(v, 0, "verbosity level"); +DEFINE_bool(help, false, "show usage information"); +DEFINE_bool(helpshort, false, "show brief usage information"); +DEFINE_string(tmpdir, private_tmpdir ? private_tmpdir : "/tmp", + "temporary directory"); + +using namespace std; + +static string flag_usage; +static string prog_src; + +void SetFlags(const char *usage, int *argc, char ***argv, + bool remove_flags, const char *src) { + flag_usage = usage; + prog_src = src; + int index = 1; + for (; index < *argc; ++index) { + string argval = (*argv)[index]; + if (argval[0] != '-' || argval == "-") break; + while (argval[0] == '-') argval = argval.substr(1); // Removes initial '-'. + string arg = argval; + string val = ""; + // Splits argval (arg=val) into arg and val. + auto pos = argval.find("="); + if (pos != string::npos) { + arg = argval.substr(0, pos); + val = argval.substr(pos + 1); + } + auto bool_register = FlagRegister::GetRegister(); + if (bool_register->SetFlag(arg, val)) + continue; + auto string_register = FlagRegister::GetRegister(); + if (string_register->SetFlag(arg, val)) + continue; + auto int32_register = FlagRegister::GetRegister(); + if (int32_register->SetFlag(arg, val)) + continue; + auto int64_register = FlagRegister::GetRegister(); + if (int64_register->SetFlag(arg, val)) + continue; + auto double_register = FlagRegister::GetRegister(); + if (double_register->SetFlag(arg, val)) + continue; + LOG(FATAL) << "SetFlags: Bad option: " << (*argv)[index]; + } + if (remove_flags) { + for (auto i = 0; i < *argc - index; ++i) { + (*argv)[i + 1] = (*argv)[i + index]; + } + *argc -= index - 1; + } + if (FLAGS_help) { + ShowUsage(true); + exit(1); + } + if (FLAGS_helpshort) { + ShowUsage(false); + exit(1); + } +} + +// If flag is defined in file 'src' and 'in_src' true or is not +// defined in file 'src' and 'in_src' is false, then print usage. +static void +ShowUsageRestrict(const std::set> &usage_set, + const string &src, bool in_src, bool show_file) { + string old_file; + bool file_out = false; + bool usage_out = false; + for (const auto &pair : usage_set) { + const auto &file = pair.first; + const auto &usage = pair.second; + bool match = file == src; + if ((match && !in_src) || (!match && in_src)) continue; + if (file != old_file) { + if (show_file) { + if (file_out) cout << "\n"; + cout << "Flags from: " << file << "\n"; + file_out = true; + } + old_file = file; + } + cout << usage << "\n"; + usage_out = true; + } + if (usage_out) cout << "\n"; +} + +void ShowUsage(bool long_usage) { + std::set> usage_set; + cout << flag_usage << "\n"; + auto bool_register = FlagRegister::GetRegister(); + bool_register->GetUsage(&usage_set); + auto string_register = FlagRegister::GetRegister(); + string_register->GetUsage(&usage_set); + auto int32_register = FlagRegister::GetRegister(); + int32_register->GetUsage(&usage_set); + auto int64_register = FlagRegister::GetRegister(); + int64_register->GetUsage(&usage_set); + auto double_register = FlagRegister::GetRegister(); + double_register->GetUsage(&usage_set); + if (!prog_src.empty()) { + cout << "PROGRAM FLAGS:\n\n"; + ShowUsageRestrict(usage_set, prog_src, true, false); + } + if (!long_usage) return; + if (!prog_src.empty()) cout << "LIBRARY FLAGS:\n\n"; + ShowUsageRestrict(usage_set, prog_src, false, true); +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/fst-types.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/fst-types.cc new file mode 100644 index 0000000000..6e467ba67e --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/fst-types.cc @@ -0,0 +1,35 @@ +// Registration of common Fst and arc types. + +#include +#include +#include +#include +#include +#include + +namespace fst { + +// Registers VectorFst, ConstFst and EditFst for common arcs types. +REGISTER_FST(VectorFst, StdArc); +REGISTER_FST(VectorFst, LogArc); +REGISTER_FST(VectorFst, Log64Arc); +REGISTER_FST(ConstFst, StdArc); +REGISTER_FST(ConstFst, LogArc); +REGISTER_FST(ConstFst, Log64Arc); +REGISTER_FST(EditFst, StdArc); +REGISTER_FST(EditFst, LogArc); +REGISTER_FST(EditFst, Log64Arc); + +// Register CompactFst for common arcs with the default (uint32) size type +REGISTER_FST(CompactStringFst, StdArc); +REGISTER_FST(CompactStringFst, LogArc); +REGISTER_FST(CompactWeightedStringFst, StdArc); +REGISTER_FST(CompactWeightedStringFst, LogArc); +REGISTER_FST(CompactAcceptorFst, StdArc); +REGISTER_FST(CompactAcceptorFst, LogArc); +REGISTER_FST(CompactUnweightedFst, StdArc); +REGISTER_FST(CompactUnweightedFst, LogArc); +REGISTER_FST(CompactUnweightedAcceptorFst, StdArc); +REGISTER_FST(CompactUnweightedAcceptorFst, LogArc); + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/fst.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/fst.cc new file mode 100644 index 0000000000..d2f18c08ed --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/fst.cc @@ -0,0 +1,151 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// FST definitions. + +#include + +#include + +#include +#include +#include // declarations of *_lookahead_fst_type + +// FST flag definitions. + +DEFINE_bool(fst_verify_properties, false, + "Verify FST properties queried by TestProperties"); + +DEFINE_bool(fst_default_cache_gc, true, "Enable garbage collection of cache"); + +DEFINE_int64(fst_default_cache_gc_limit, 1 << 20LL, + "Cache byte size that triggers garbage collection"); + +DEFINE_bool(fst_align, false, "Write FST data aligned where appropriate"); + +DEFINE_string(save_relabel_ipairs, "", "Save input relabel pairs to file"); +DEFINE_string(save_relabel_opairs, "", "Save output relabel pairs to file"); + +DEFINE_string(fst_read_mode, "read", + "Default file reading mode for mappable files"); + +namespace fst { + +// FST type definitions for lookahead FSTs. +const char arc_lookahead_fst_type[] = "arc_lookahead"; +const char ilabel_lookahead_fst_type[] = "ilabel_lookahead"; +const char olabel_lookahead_fst_type[] = "olabel_lookahead"; + +// Identifies stream data as an FST (and its endianity). +constexpr int32 kFstMagicNumber = 2125659606; + +// Checks for FST magic number in stream, to indicate caller function that the +// stream content is an FST header. +bool IsFstHeader(std::istream &strm, const string &source) { + int64 pos = strm.tellg(); + bool match = true; + int32 magic_number = 0; + ReadType(strm, &magic_number); + if (magic_number != kFstMagicNumber) { + match = false; + } + strm.seekg(pos); + return match; +} + +// Checks FST magic number and reads in the header; if rewind = true, +// the stream is repositioned before call if possible. +bool FstHeader::Read(std::istream &strm, const string &source, bool rewind) { + int64 pos = 0; + if (rewind) pos = strm.tellg(); + int32 magic_number = 0; + ReadType(strm, &magic_number); + if (magic_number != kFstMagicNumber) { + LOG(ERROR) << "FstHeader::Read: Bad FST header: " << source; + if (rewind) strm.seekg(pos); + return false; + } + ReadType(strm, &fsttype_); + ReadType(strm, &arctype_); + ReadType(strm, &version_); + ReadType(strm, &flags_); + ReadType(strm, &properties_); + ReadType(strm, &start_); + ReadType(strm, &numstates_); + ReadType(strm, &numarcs_); + if (!strm) { + LOG(ERROR) << "FstHeader::Read: Read failed: " << source; + return false; + } + if (rewind) strm.seekg(pos); + return true; +} + +// Writes FST magic number and FST header. +bool FstHeader::Write(std::ostream &strm, const string &source) const { + WriteType(strm, kFstMagicNumber); + WriteType(strm, fsttype_); + WriteType(strm, arctype_); + WriteType(strm, version_); + WriteType(strm, flags_); + WriteType(strm, properties_); + WriteType(strm, start_); + WriteType(strm, numstates_); + WriteType(strm, numarcs_); + return true; +} + +string FstHeader::DebugString() const { + std::ostringstream ostrm; + ostrm << "fsttype: \"" << fsttype_ << "\" arctype: \"" << arctype_ + << "\" version: \"" << version_ << "\" flags: \"" << flags_ + << "\" properties: \"" << properties_ << "\" start: \"" << start_ + << "\" numstates: \"" << numstates_ << "\" numarcs: \"" << numarcs_ + << "\""; + return ostrm.str(); +} + +FstReadOptions::FstReadOptions(const string &source, const FstHeader *header, + const SymbolTable *isymbols, + const SymbolTable *osymbols) + : source(source), + header(header), + isymbols(isymbols), + osymbols(osymbols), + read_isymbols(true), + read_osymbols(true) { + mode = ReadMode(FLAGS_fst_read_mode); +} + +FstReadOptions::FstReadOptions(const string &source, + const SymbolTable *isymbols, + const SymbolTable *osymbols) + : source(source), + header(nullptr), + isymbols(isymbols), + osymbols(osymbols), + read_isymbols(true), + read_osymbols(true) { + mode = ReadMode(FLAGS_fst_read_mode); +} + +FstReadOptions::FileReadMode FstReadOptions::ReadMode(const string &mode) { + if (mode == "read") return READ; + if (mode == "map") return MAP; + LOG(ERROR) << "Unknown file read mode " << mode; + return READ; +} + +string FstReadOptions::DebugString() const { + std::ostringstream ostrm; + ostrm << "source: \"" << source << "\" mode: \"" + << (mode == READ ? "READ" : "MAP") << "\" read_isymbols: \"" + << (read_isymbols ? "true" : "false") << "\" read_osymbols: \"" + << (read_osymbols ? "true" : "false") << "\" header: \"" + << (header ? "set" : "null") << "\" isymbols: \"" + << (isymbols ? "set" : "null") << "\" osymbols: \"" + << (osymbols ? "set" : "null") << "\""; + return ostrm.str(); +} + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/mapped-file.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/mapped-file.cc new file mode 100644 index 0000000000..0c396ea601 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/mapped-file.cc @@ -0,0 +1,122 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// + +#include + +#include +#include +#include +#include + +#include +#include +#include + +#include + +namespace fst { + +MappedFile::MappedFile(const MemoryRegion ®ion) : region_(region) {} + +MappedFile::~MappedFile() { + if (region_.size != 0) { + if (region_.mmap) { + VLOG(1) << "munmap'ed " << region_.size << " bytes at " << region_.mmap; + if (munmap(region_.mmap, region_.size) != 0) { + LOG(ERROR) << "Failed to unmap region: " << strerror(errno); + } + } else { + if (region_.data) { + operator delete(static_cast(region_.data) - region_.offset); + } + } + } +} + +MappedFile *MappedFile::Map(std::istream *istrm, bool memorymap, + const string &source, size_t size) { + const auto spos = istrm->tellg(); + VLOG(1) << "memorymap: " << (memorymap ? "true" : "false") << " source: \"" + << source << "\"" + << " size: " << size << " offset: " << spos; + if (memorymap && spos >= 0 && spos % kArchAlignment == 0) { + const size_t pos = spos; + int fd = open(source.c_str(), O_RDONLY); + if (fd != -1) { + const int pagesize = sysconf(_SC_PAGESIZE); + const off_t offset = pos % pagesize; + const off_t upsize = size + offset; + void *map = + mmap(nullptr, upsize, PROT_READ, MAP_SHARED, fd, pos - offset); + auto *data = reinterpret_cast(map); + if (close(fd) == 0 && map != MAP_FAILED) { + MemoryRegion region; + region.mmap = map; + region.size = upsize; + region.data = reinterpret_cast(data + offset); + region.offset = offset; + std::unique_ptr mmf(new MappedFile(region)); + istrm->seekg(pos + size, std::ios::beg); + if (istrm) { + VLOG(1) << "mmap'ed region of " << size << " at offset " << pos + << " from " << source << " to addr " << map; + return mmf.release(); + } + } else { + LOG(INFO) << "Mapping of file failed: " << strerror(errno); + } + } + } + // If all else fails, reads from the file into the allocated buffer. + if (memorymap) { + LOG(WARNING) << "File mapping at offset " << spos << " of file " << source + << " could not be honored, reading instead"; + } + // Reads the file into the buffer in chunks not larger than kMaxReadChunk. + std::unique_ptr mf(Allocate(size)); + auto *buffer = reinterpret_cast(mf->mutable_data()); + while (size > 0) { + const auto next_size = std::min(size, kMaxReadChunk); + const auto current_pos = istrm->tellg(); + if (!istrm->read(buffer, next_size)) { + LOG(ERROR) << "Failed to read " << next_size << " bytes at offset " + << current_pos << "from \"" << source << "\""; + return nullptr; + } + size -= next_size; + buffer += next_size; + VLOG(2) << "Read " << next_size << " bytes. " << size << " remaining"; + } + return mf.release(); +} + +MappedFile *MappedFile::Allocate(size_t size, int align) { + MemoryRegion region; + region.data = nullptr; + region.offset = 0; + if (size > 0) { + char *buffer = static_cast(operator new(size + align)); + size_t address = reinterpret_cast(buffer); + region.offset = kArchAlignment - (address % align); + region.data = buffer + region.offset; + } + region.mmap = nullptr; + region.size = size; + return new MappedFile(region); +} + +MappedFile *MappedFile::Borrow(void *data) { + MemoryRegion region; + region.data = data; + region.mmap = data; + region.size = 0; + region.offset = 0; + return new MappedFile(region); +} + +constexpr int MappedFile::kArchAlignment; + +constexpr size_t MappedFile::kMaxReadChunk; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/properties.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/properties.cc new file mode 100644 index 0000000000..eea1d11d68 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/properties.cc @@ -0,0 +1,421 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Functions for updating property bits for various FST operations and +// string names of the properties. + +#include + +#include +#include + +namespace fst { + +// These functions determine the properties associated with the FST result of +// various finite-state operations. The property arguments correspond to the +// operation's FST arguments. The properties returned assume the operation +// modifies its first argument. Bitwise-and this result with kCopyProperties for +// the case when a new (possibly delayed) FST is instead constructed. + +// Properties for a concatenatively-closed FST. +uint64 ClosureProperties(uint64 inprops, bool star, bool delayed) { + auto outprops = (kError | kAcceptor | kUnweighted | kAccessible) & inprops; + if (inprops & kUnweighted) outprops |= kUnweightedCycles; + if (!delayed) { + outprops |= + (kExpanded | kMutable | kCoAccessible | kNotTopSorted | kNotString) & + inprops; + } + if (!delayed || inprops & kAccessible) { + outprops |= (kNotAcceptor | kNonIDeterministic | kNonODeterministic | + kNotILabelSorted | kNotOLabelSorted | kWeighted | + kWeightedCycles | kNotAccessible | kNotCoAccessible) & inprops; + if ((inprops & kWeighted) && (inprops & kAccessible) && + (inprops & kCoAccessible)) { + outprops |= kWeightedCycles; + } + } + return outprops; +} + +// Properties for a complemented FST. +uint64 ComplementProperties(uint64 inprops) { + auto outprops = kAcceptor | kUnweighted | kUnweightedCycles | kNoEpsilons | + kNoIEpsilons | kNoOEpsilons | kIDeterministic | + kODeterministic | kAccessible; + outprops |= + (kError | kILabelSorted | kOLabelSorted | kInitialCyclic) & inprops; + if (inprops & kAccessible) { + outprops |= kNotILabelSorted | kNotOLabelSorted | kCyclic; + } + return outprops; +} + +// Properties for a composed FST. +uint64 ComposeProperties(uint64 inprops1, uint64 inprops2) { + auto outprops = kError & (inprops1 | inprops2); + if (inprops1 & kAcceptor && inprops2 & kAcceptor) { + outprops |= kAcceptor | kAccessible; + outprops |= (kNoEpsilons | kNoIEpsilons | kNoOEpsilons | kAcyclic | + kInitialAcyclic) & + inprops1 & inprops2; + if (kNoIEpsilons & inprops1 & inprops2) { + outprops |= (kIDeterministic | kODeterministic) & inprops1 & inprops2; + } + } else { + outprops |= kAccessible; + outprops |= (kAcceptor | kNoIEpsilons | kAcyclic | kInitialAcyclic) & + inprops1 & inprops2; + if (kNoIEpsilons & inprops1 & inprops2) { + outprops |= kIDeterministic & inprops1 & inprops2; + } + } + return outprops; +} + +// Properties for a concatenated FST. +uint64 ConcatProperties(uint64 inprops1, uint64 inprops2, bool delayed) { + auto outprops = (kAcceptor | kUnweighted | kUnweightedCycles | kAcyclic) & + inprops1 & inprops2; + outprops |= kError & (inprops1 | inprops2); + const bool empty1 = delayed; // Can the first FST be the empty machine? + const bool empty2 = delayed; // Can the second FST be the empty machine? + if (!delayed) { + outprops |= (kExpanded | kMutable | kNotTopSorted | kNotString) & inprops1; + outprops |= (kNotTopSorted | kNotString) & inprops2; + } + if (!empty1) outprops |= (kInitialAcyclic | kInitialCyclic) & inprops1; + if (!delayed || inprops1 & kAccessible) { + outprops |= (kNotAcceptor | kNonIDeterministic | kNonODeterministic | + kEpsilons | kIEpsilons | kOEpsilons | kNotILabelSorted | + kNotOLabelSorted | kWeighted | kWeightedCycles | kCyclic | + kNotAccessible | kNotCoAccessible) & + inprops1; + } + if ((inprops1 & (kAccessible | kCoAccessible)) == + (kAccessible | kCoAccessible) && + !empty1) { + outprops |= kAccessible & inprops2; + if (!empty2) outprops |= kCoAccessible & inprops2; + if (!delayed || inprops2 & kAccessible) { + outprops |= (kNotAcceptor | kNonIDeterministic | kNonODeterministic | + kEpsilons | kIEpsilons | kOEpsilons | kNotILabelSorted | + kNotOLabelSorted | kWeighted | kWeightedCycles | kCyclic | + kNotAccessible | kNotCoAccessible) & + inprops2; + } + } + return outprops; +} + +// Properties for a determinized FST. +uint64 DeterminizeProperties(uint64 inprops, bool has_subsequential_label, + bool distinct_psubsequential_labels) { + auto outprops = kAccessible; + if ((kAcceptor & inprops) || + ((kNoIEpsilons & inprops) && distinct_psubsequential_labels) || + (has_subsequential_label && distinct_psubsequential_labels)) { + outprops |= kIDeterministic; + } + outprops |= (kError | kAcceptor | kAcyclic | kInitialAcyclic | kCoAccessible | + kString) & + inprops; + if ((inprops & kNoIEpsilons) && distinct_psubsequential_labels) { + outprops |= kNoEpsilons & inprops; + } + if (inprops & kAccessible) { + outprops |= (kIEpsilons | kOEpsilons | kCyclic) & inprops; + } + if (inprops & kAcceptor) outprops |= (kNoIEpsilons | kNoOEpsilons) & inprops; + if ((inprops & kNoIEpsilons) && has_subsequential_label) { + outprops |= kNoIEpsilons; + } + return outprops; +} + +// Properties for factored weight FST. +uint64 FactorWeightProperties(uint64 inprops) { + auto outprops = (kExpanded | kMutable | kError | kAcceptor | kAcyclic | + kAccessible | kCoAccessible) & + inprops; + if (inprops & kAccessible) { + outprops |= (kNotAcceptor | kNonIDeterministic | kNonODeterministic | + kEpsilons | kIEpsilons | kOEpsilons | kCyclic | + kNotILabelSorted | kNotOLabelSorted) & + inprops; + } + return outprops; +} + +// Properties for an inverted FST. +uint64 InvertProperties(uint64 inprops) { + auto outprops = (kExpanded | kMutable | kError | kAcceptor | kNotAcceptor | + kEpsilons | kNoEpsilons | kWeighted | kUnweighted | + kWeightedCycles | kUnweightedCycles | kCyclic | kAcyclic | + kInitialCyclic | kInitialAcyclic | kTopSorted | + kNotTopSorted | kAccessible | kNotAccessible | + kCoAccessible | kNotCoAccessible | kString | kNotString) & + inprops; + if (kIDeterministic & inprops) outprops |= kODeterministic; + if (kNonIDeterministic & inprops) outprops |= kNonODeterministic; + if (kODeterministic & inprops) outprops |= kIDeterministic; + if (kNonODeterministic & inprops) outprops |= kNonIDeterministic; + + if (kIEpsilons & inprops) outprops |= kOEpsilons; + if (kNoIEpsilons & inprops) outprops |= kNoOEpsilons; + if (kOEpsilons & inprops) outprops |= kIEpsilons; + if (kNoOEpsilons & inprops) outprops |= kNoIEpsilons; + + if (kILabelSorted & inprops) outprops |= kOLabelSorted; + if (kNotILabelSorted & inprops) outprops |= kNotOLabelSorted; + if (kOLabelSorted & inprops) outprops |= kILabelSorted; + if (kNotOLabelSorted & inprops) outprops |= kNotILabelSorted; + return outprops; +} + +// Properties for a projected FST. +uint64 ProjectProperties(uint64 inprops, bool project_input) { + auto outprops = kAcceptor; + outprops |= (kExpanded | kMutable | kError | kWeighted | kUnweighted | + kWeightedCycles | kUnweightedCycles | + kCyclic | kAcyclic | kInitialCyclic | kInitialAcyclic | + kTopSorted | kNotTopSorted | kAccessible | kNotAccessible | + kCoAccessible | kNotCoAccessible | kString | kNotString) & + inprops; + if (project_input) { + outprops |= (kIDeterministic | kNonIDeterministic | kIEpsilons | + kNoIEpsilons | kILabelSorted | kNotILabelSorted) & + inprops; + + if (kIDeterministic & inprops) outprops |= kODeterministic; + if (kNonIDeterministic & inprops) outprops |= kNonODeterministic; + + if (kIEpsilons & inprops) outprops |= kOEpsilons | kEpsilons; + if (kNoIEpsilons & inprops) outprops |= kNoOEpsilons | kNoEpsilons; + + if (kILabelSorted & inprops) outprops |= kOLabelSorted; + if (kNotILabelSorted & inprops) outprops |= kNotOLabelSorted; + } else { + outprops |= (kODeterministic | kNonODeterministic | kOEpsilons | + kNoOEpsilons | kOLabelSorted | kNotOLabelSorted) & + inprops; + + if (kODeterministic & inprops) outprops |= kIDeterministic; + if (kNonODeterministic & inprops) outprops |= kNonIDeterministic; + + if (kOEpsilons & inprops) outprops |= kIEpsilons | kEpsilons; + if (kNoOEpsilons & inprops) outprops |= kNoIEpsilons | kNoEpsilons; + + if (kOLabelSorted & inprops) outprops |= kILabelSorted; + if (kNotOLabelSorted & inprops) outprops |= kNotILabelSorted; + } + return outprops; +} + +// Properties for a randgen FST. +uint64 RandGenProperties(uint64 inprops, bool weighted) { + auto outprops = kAcyclic | kInitialAcyclic | kAccessible | kUnweightedCycles; + outprops |= inprops & kError; + if (weighted) { + outprops |= kTopSorted; + outprops |= + (kAcceptor | kNoEpsilons | kNoIEpsilons | kNoOEpsilons | + kIDeterministic | kODeterministic | kILabelSorted | kOLabelSorted) & + inprops; + } else { + outprops |= kUnweighted; + outprops |= (kAcceptor | kILabelSorted | kOLabelSorted) & inprops; + } + return outprops; +} + +// Properties for a replace FST. +uint64 ReplaceProperties(const std::vector& inprops, ssize_t root, + bool epsilon_on_call, bool epsilon_on_return, + bool out_epsilon_on_call, bool out_epsilon_on_return, + bool replace_transducer, bool no_empty_fsts, + bool all_ilabel_sorted, bool all_olabel_sorted, + bool all_negative_or_dense) { + if (inprops.empty()) return kNullProperties; + uint64 outprops = 0; + for (auto inprop : inprops) outprops |= kError & inprop; + uint64 access_props = no_empty_fsts ? kAccessible | kCoAccessible : 0; + for (auto inprop : inprops) { + access_props &= (inprop & (kAccessible | kCoAccessible)); + } + if (access_props == (kAccessible | kCoAccessible)) { + outprops |= access_props; + if (inprops[root] & kInitialCyclic) outprops |= kInitialCyclic; + uint64 props = 0; + bool string = true; + for (auto inprop : inprops) { + if (replace_transducer) props |= kNotAcceptor & inprop; + props |= (kNonIDeterministic | kNonODeterministic | kEpsilons | + kIEpsilons | kOEpsilons | kWeighted | kWeightedCycles | + kCyclic | kNotTopSorted | kNotString) & inprop; + if (!(inprop & kString)) string = false; + } + outprops |= props; + if (string) outprops |= kString; + } + bool acceptor = !replace_transducer; + bool ideterministic = !epsilon_on_call && epsilon_on_return; + bool no_iepsilons = !epsilon_on_call && !epsilon_on_return; + bool acyclic = true; + bool unweighted = true; + for (size_t i = 0; i < inprops.size(); ++i) { + if (!(inprops[i] & kAcceptor)) acceptor = false; + if (!(inprops[i] & kIDeterministic)) ideterministic = false; + if (!(inprops[i] & kNoIEpsilons)) no_iepsilons = false; + if (!(inprops[i] & kAcyclic)) acyclic = false; + if (!(inprops[i] & kUnweighted)) unweighted = false; + if (i != root && !(inprops[i] & kNoIEpsilons)) ideterministic = false; + } + if (acceptor) outprops |= kAcceptor; + if (ideterministic) outprops |= kIDeterministic; + if (no_iepsilons) outprops |= kNoIEpsilons; + if (acyclic) outprops |= kAcyclic; + if (unweighted) outprops |= kUnweighted; + if (inprops[root] & kInitialAcyclic) outprops |= kInitialAcyclic; + // We assume that all terminals are positive. The resulting ReplaceFst is + // known to be kILabelSorted when: (1) all sub-FSTs are kILabelSorted, (2) the + // input label of the return arc is epsilon, and (3) one of the 3 following + // conditions is satisfied: + // + // 1. the input label of the call arc is not epsilon + // 2. all non-terminals are negative, or + // 3. all non-terninals are positive and form a dense range containing 1. + if (all_ilabel_sorted && epsilon_on_return && + (!epsilon_on_call || all_negative_or_dense)) { + outprops |= kILabelSorted; + } + // Similarly, the resulting ReplaceFst is known to be kOLabelSorted when: (1) + // all sub-FSTs are kOLabelSorted, (2) the output label of the return arc is + // epsilon, and (3) one of the 3 following conditions is satisfied: + // + // 1. the output label of the call arc is not epsilon + // 2. all non-terminals are negative, or + // 3. all non-terninals are positive and form a dense range containing 1. + if (all_olabel_sorted && out_epsilon_on_return && + (!out_epsilon_on_call || all_negative_or_dense)) { + outprops |= kOLabelSorted; + } + return outprops; +} + +// Properties for a relabeled FST. +uint64 RelabelProperties(uint64 inprops) { + static constexpr auto outprops = + kExpanded | kMutable | kError | kWeighted | kUnweighted | + kWeightedCycles | kUnweightedCycles | kCyclic | kAcyclic | + kInitialCyclic | kInitialAcyclic | kTopSorted | kNotTopSorted | + kAccessible | kNotAccessible | kCoAccessible | kNotCoAccessible | + kString | kNotString; + return outprops & inprops; +} + +// Properties for a reversed FST (the superinitial state limits this set). +uint64 ReverseProperties(uint64 inprops, bool has_superinitial) { + auto outprops = (kExpanded | kMutable | kError | kAcceptor | kNotAcceptor | + kEpsilons | kIEpsilons | kOEpsilons | kUnweighted | kCyclic | + kAcyclic | kWeightedCycles | kUnweightedCycles) & + inprops; + if (has_superinitial) outprops |= kWeighted & inprops; + return outprops; +} + +// Properties for re-weighted FST. +uint64 ReweightProperties(uint64 inprops) { + auto outprops = inprops & kWeightInvariantProperties; + outprops = outprops & ~kCoAccessible; + return outprops; +} + +// Properties for an epsilon-removed FST. +uint64 RmEpsilonProperties(uint64 inprops, bool delayed) { + auto outprops = kNoEpsilons; + outprops |= (kError | kAcceptor | kAcyclic | kInitialAcyclic) & inprops; + if (inprops & kAcceptor) outprops |= kNoIEpsilons | kNoOEpsilons; + if (!delayed) { + outprops |= kExpanded | kMutable; + outprops |= kTopSorted & inprops; + } + if (!delayed || inprops & kAccessible) outprops |= kNotAcceptor & inprops; + return outprops; +} + +// Properties for shortest path. This function computes how the properties of +// the output of shortest path need to be updated, given that 'props' is already +// known. +uint64 ShortestPathProperties(uint64 props, bool tree) { + auto outprops = + props | kAcyclic | kInitialAcyclic | kAccessible | kUnweightedCycles; + if (!tree) outprops |= kCoAccessible; + return outprops; +} + +// Properties for a synchronized FST. +uint64 SynchronizeProperties(uint64 inprops) { + auto outprops = (kError | kAcceptor | kAcyclic | kAccessible | kCoAccessible | + kUnweighted | kUnweightedCycles) & + inprops; + if (inprops & kAccessible) { + outprops |= (kCyclic | kNotCoAccessible | kWeighted | kWeightedCycles) & + inprops; + } + return outprops; +} + +// Properties for a unioned FST. +uint64 UnionProperties(uint64 inprops1, uint64 inprops2, bool delayed) { + auto outprops = + (kAcceptor | kUnweighted | kUnweightedCycles | kAcyclic | kAccessible) & + inprops1 & inprops2; + outprops |= kError & (inprops1 | inprops2); + outprops |= kInitialAcyclic; + bool empty1 = delayed; // Can the first FST be the empty machine? + bool empty2 = delayed; // Can the second FST be the empty machine? + if (!delayed) { + outprops |= (kExpanded | kMutable | kNotTopSorted) & inprops1; + outprops |= kNotTopSorted & inprops2; + } + if (!empty1 && !empty2) { + outprops |= kEpsilons | kIEpsilons | kOEpsilons; + outprops |= kCoAccessible & inprops1 & inprops2; + } + // Note kNotCoAccessible does not hold because of kInitialAcyclic option. + if (!delayed || inprops1 & kAccessible) { + outprops |= + (kNotAcceptor | kNonIDeterministic | kNonODeterministic | kEpsilons | + kIEpsilons | kOEpsilons | kNotILabelSorted | kNotOLabelSorted | + kWeighted | kWeightedCycles | kCyclic | kNotAccessible) & + inprops1; + } + if (!delayed || inprops2 & kAccessible) { + outprops |= (kNotAcceptor | kNonIDeterministic | kNonODeterministic | + kEpsilons | kIEpsilons | kOEpsilons | kNotILabelSorted | + kNotOLabelSorted | kWeighted | kWeightedCycles | kCyclic | + kNotAccessible | kNotCoAccessible) & + inprops2; + } + return outprops; +} + +// Property string names (indexed by bit position). +const char* PropertyNames[] = { + // Binary. + "expanded", "mutable", "error", "", "", "", "", "", "", "", "", "", "", "", + "", "", + // Ternary. + "acceptor", "not acceptor", "input deterministic", + "non input deterministic", "output deterministic", + "non output deterministic", "input/output epsilons", + "no input/output epsilons", "input epsilons", "no input epsilons", + "output epsilons", "no output epsilons", "input label sorted", + "not input label sorted", "output label sorted", "not output label sorted", + "weighted", "unweighted", "cyclic", "acyclic", "cyclic at initial state", + "acyclic at initial state", "top sorted", "not top sorted", "accessible", + "not accessible", "coaccessible", "not coaccessible", "string", + "not string", "weighted cycles", "unweighted cycles"}; + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/symbol-table-ops.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/symbol-table-ops.cc new file mode 100644 index 0000000000..75a06ef944 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/symbol-table-ops.cc @@ -0,0 +1,121 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// + +#include + +#include + +namespace fst { + +SymbolTable *MergeSymbolTable(const SymbolTable &left, const SymbolTable &right, + bool *right_relabel_output) { + // MergeSymbolTable detects several special cases. It will return a reference + // copied version of SymbolTable of left or right if either symbol table is + // a superset of the other. + std::unique_ptr merged( + new SymbolTable("merge_" + left.Name() + "_" + right.Name())); + // Copies everything from the left symbol table. + bool left_has_all = true; + bool right_has_all = true; + bool relabel = false; + for (SymbolTableIterator liter(left); !liter.Done(); liter.Next()) { + merged->AddSymbol(liter.Symbol(), liter.Value()); + if (right_has_all) { + int64 key = right.Find(liter.Symbol()); + if (key == -1) { + right_has_all = false; + } else if (!relabel && key != liter.Value()) { + relabel = true; + } + } + } + if (right_has_all) { + if (right_relabel_output) *right_relabel_output = relabel; + return right.Copy(); + } + // add all symbols we can from right symbol table + std::vector conflicts; + for (SymbolTableIterator riter(right); !riter.Done(); riter.Next()) { + int64 key = merged->Find(riter.Symbol()); + if (key != -1) { + // Symbol already exists, maybe with different value + if (key != riter.Value()) relabel = true; + continue; + } + // Symbol doesn't exist from left + left_has_all = false; + if (!merged->Find(riter.Value()).empty()) { + // we can't add this where we want to, add it later, in order + conflicts.push_back(riter.Symbol()); + continue; + } + // there is a hole and we can add this symbol with its id + merged->AddSymbol(riter.Symbol(), riter.Value()); + } + if (right_relabel_output) *right_relabel_output = relabel; + if (left_has_all) return left.Copy(); + // Add all symbols that conflicted, in order + for (const auto &conflict : conflicts) merged->AddSymbol(conflict); + return merged.release(); +} + +SymbolTable *CompactSymbolTable(const SymbolTable &syms) { + std::map sorted; + SymbolTableIterator stiter(syms); + for (; !stiter.Done(); stiter.Next()) { + sorted[stiter.Value()] = stiter.Symbol(); + } + auto *compact = new SymbolTable(syms.Name() + "_compact"); + int64 newkey = 0; + for (const auto &kv : sorted) compact->AddSymbol(kv.second, newkey++); + return compact; +} + +SymbolTable *FstReadSymbols(const string &filename, bool input_symbols) { + std::ifstream in(filename, std::ios_base::in | std::ios_base::binary); + if (!in) { + LOG(ERROR) << "FstReadSymbols: Can't open file " << filename; + return nullptr; + } + FstHeader hdr; + if (!hdr.Read(in, filename)) { + LOG(ERROR) << "FstReadSymbols: Couldn't read header from " << filename; + return nullptr; + } + if (hdr.GetFlags() & FstHeader::HAS_ISYMBOLS) { + std::unique_ptr isymbols(SymbolTable::Read(in, filename)); + if (isymbols == nullptr) { + LOG(ERROR) << "FstReadSymbols: Couldn't read input symbols from " + << filename; + return nullptr; + } + if (input_symbols) return isymbols.release(); + } + if (hdr.GetFlags() & FstHeader::HAS_OSYMBOLS) { + std::unique_ptr osymbols(SymbolTable::Read(in, filename)); + if (osymbols == nullptr) { + LOG(ERROR) << "FstReadSymbols: Couldn't read output symbols from " + << filename; + return nullptr; + } + if (!input_symbols) return osymbols.release(); + } + LOG(ERROR) << "FstReadSymbols: The file " << filename + << " doesn't contain the requested symbols"; + return nullptr; +} + +bool AddAuxiliarySymbols(const string &prefix, int64 start_label, + int64 nlabels, SymbolTable *syms) { + for (int64 i = 0; i < nlabels; ++i) { + auto index = i + start_label; + if (index != syms->AddSymbol(prefix + std::to_string(i), index)) { + FSTERROR() << "AddAuxiliarySymbols: Symbol table clash"; + return false; + } + } + return true; +} + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/symbol-table.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/symbol-table.cc new file mode 100644 index 0000000000..b113596216 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/symbol-table.cc @@ -0,0 +1,363 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Classes to provide symbol-to-integer and integer-to-symbol mappings. + +#include + +#include +#include + +#include +#include + +DEFINE_bool(fst_compat_symbols, true, + "Require symbol tables to match when appropriate"); +DEFINE_string(fst_field_separator, "\t ", + "Set of characters used as a separator between printed fields"); + +namespace fst { + +// Maximum line length in textual symbols file. +static constexpr int kLineLen = 8096; + +// Identifies stream data as a symbol table (and its endianity). +static constexpr int32 kSymbolTableMagicNumber = 2125658996; + +SymbolTableTextOptions::SymbolTableTextOptions(bool allow_negative_labels) + : allow_negative_labels(allow_negative_labels), + fst_field_separator(FLAGS_fst_field_separator) {} + +namespace internal { + +SymbolTableImpl *SymbolTableImpl::ReadText(std::istream &strm, + const string &filename, + const SymbolTableTextOptions &opts) { + std::unique_ptr impl(new SymbolTableImpl(filename)); + int64 nline = 0; + char line[kLineLen]; + while (!strm.getline(line, kLineLen).fail()) { + ++nline; + std::vector col; + auto separator = opts.fst_field_separator + "\n"; + SplitString(line, separator.c_str(), &col, true); + if (col.empty()) continue; // Empty line. + if (col.size() != 2) { + LOG(ERROR) << "SymbolTable::ReadText: Bad number of columns (" + << col.size() << "), " + << "file = " << filename << ", line = " << nline << ":<" + << line << ">"; + return nullptr; + } + const char *symbol = col[0]; + const char *value = col[1]; + char *p; + const auto key = strtoll(value, &p, 10); + if (p < value + strlen(value) || (!opts.allow_negative_labels && key < 0) || + key == kNoSymbol) { + LOG(ERROR) << "SymbolTable::ReadText: Bad non-negative integer \"" + << value << "\", " + << "file = " << filename << ", line = " << nline; + return nullptr; + } + impl->AddSymbol(symbol, key); + } + return impl.release(); +} + +void SymbolTableImpl::MaybeRecomputeCheckSum() const { + { + ReaderMutexLock check_sum_lock(&check_sum_mutex_); + if (check_sum_finalized_) return; + } + // We'll acquire an exclusive lock to recompute the checksums. + MutexLock check_sum_lock(&check_sum_mutex_); + if (check_sum_finalized_) { // Another thread (coming in around the same time + return; // might have done it already). So we recheck. + } + // Calculates the original label-agnostic checksum. + CheckSummer check_sum; + for (size_t i = 0; i < symbols_.size(); ++i) { + const auto &symbol = symbols_.GetSymbol(i); + check_sum.Update(symbol.data(), symbol.size()); + check_sum.Update("", 1); + } + check_sum_string_ = check_sum.Digest(); + // Calculates the safer, label-dependent checksum. + CheckSummer labeled_check_sum; + for (int64 i = 0; i < dense_key_limit_; ++i) { + std::ostringstream line; + line << symbols_.GetSymbol(i) << '\t' << i; + labeled_check_sum.Update(line.str().data(), line.str().size()); + } + using citer = map::const_iterator; + for (citer it = key_map_.begin(); it != key_map_.end(); ++it) { + // TODO(tombagby, 2013-11-22) This line maintains a bug that ignores + // negative labels in the checksum that too many tests rely on. + if (it->first < dense_key_limit_) continue; + std::ostringstream line; + line << symbols_.GetSymbol(it->second) << '\t' << it->first; + labeled_check_sum.Update(line.str().data(), line.str().size()); + } + labeled_check_sum_string_ = labeled_check_sum.Digest(); + check_sum_finalized_ = true; +} + +int64 SymbolTableImpl::AddSymbol(const string &symbol, int64 key) { + if (key == kNoSymbol) return key; + const std::pair &insert_key = symbols_.InsertOrFind(symbol); + if (!insert_key.second) { + auto key_already = GetNthKey(insert_key.first); + if (key_already == key) return key; + VLOG(1) << "SymbolTable::AddSymbol: symbol = " << symbol + << " already in symbol_map_ with key = " << key_already + << " but supplied new key = " << key << " (ignoring new key)"; + return key_already; + } + if (key == (symbols_.size() - 1) && key == dense_key_limit_) { + ++dense_key_limit_; + } else { + idx_key_.push_back(key); + key_map_[key] = symbols_.size() - 1; + } + if (key >= available_key_) available_key_ = key + 1; + check_sum_finalized_ = false; + return key; +} + +// TODO(rybach): Consider a more efficient implementation which re-uses holes in +// the dense-key range or re-arranges the dense-key range from time to time. +void SymbolTableImpl::RemoveSymbol(const int64 key) { + auto idx = key; + if (key < 0 || key >= dense_key_limit_) { + auto iter = key_map_.find(key); + if (iter == key_map_.end()) return; + idx = iter->second; + key_map_.erase(iter); + } + if (idx < 0 || idx >= symbols_.size()) return; + symbols_.RemoveSymbol(idx); + // Removed one symbol, all indexes > idx are shifted by -1. + for (auto &k : key_map_) { + if (k.second > idx) --k.second; + } + if (key >= 0 && key < dense_key_limit_) { + // Removal puts a hole in the dense key range. Adjusts range to [0, key). + const auto new_dense_key_limit = key; + for (int64 i = key + 1; i < dense_key_limit_; ++i) { + key_map_[i] = i - 1; + } + // Moves existing values in idx_key to new place. + idx_key_.resize(symbols_.size() - new_dense_key_limit); + for (int64 i = symbols_.size(); i >= dense_key_limit_; --i) { + idx_key_[i - new_dense_key_limit - 1] = idx_key_[i - dense_key_limit_]; + } + // Adds indexes for previously dense keys. + for (int64 i = new_dense_key_limit; i < dense_key_limit_ - 1; ++i) { + idx_key_[i - new_dense_key_limit] = i + 1; + } + dense_key_limit_ = new_dense_key_limit; + } else { + // Remove entry for removed index in idx_key. + for (int64 i = idx - dense_key_limit_; i < idx_key_.size() - 1; ++i) { + idx_key_[i] = idx_key_[i + 1]; + } + idx_key_.pop_back(); + } + if (key == available_key_ - 1) available_key_ = key; +} + +SymbolTableImpl *SymbolTableImpl::Read(std::istream &strm, + const SymbolTableReadOptions &opts) { + int32 magic_number = 0; + ReadType(strm, &magic_number); + if (strm.fail()) { + LOG(ERROR) << "SymbolTable::Read: Read failed"; + return nullptr; + } + string name; + ReadType(strm, &name); + std::unique_ptr impl(new SymbolTableImpl(name)); + ReadType(strm, &impl->available_key_); + int64 size; + ReadType(strm, &size); + if (strm.fail()) { + LOG(ERROR) << "SymbolTable::Read: Read failed"; + return nullptr; + } + string symbol; + int64 key; + impl->check_sum_finalized_ = false; + for (int64 i = 0; i < size; ++i) { + ReadType(strm, &symbol); + ReadType(strm, &key); + if (strm.fail()) { + LOG(ERROR) << "SymbolTable::Read: Read failed"; + return nullptr; + } + impl->AddSymbol(symbol, key); + } + return impl.release(); +} + +bool SymbolTableImpl::Write(std::ostream &strm) const { + WriteType(strm, kSymbolTableMagicNumber); + WriteType(strm, name_); + WriteType(strm, available_key_); + int64 size = symbols_.size(); + WriteType(strm, size); + for (int64 i = 0; i < size; ++i) { + auto key = (i < dense_key_limit_) ? i : idx_key_[i - dense_key_limit_]; + WriteType(strm, symbols_.GetSymbol(i)); + WriteType(strm, key); + } + strm.flush(); + if (strm.fail()) { + LOG(ERROR) << "SymbolTable::Write: Write failed"; + return false; + } + return true; +} + +} // namespace internal + +void SymbolTable::AddTable(const SymbolTable &table) { + MutateCheck(); + for (SymbolTableIterator iter(table); !iter.Done(); iter.Next()) { + impl_->AddSymbol(iter.Symbol()); + } +} + +bool SymbolTable::WriteText(std::ostream &strm, + const SymbolTableTextOptions &opts) const { + if (opts.fst_field_separator.empty()) { + LOG(ERROR) << "Missing required field separator"; + return false; + } + bool once_only = false; + for (SymbolTableIterator iter(*this); !iter.Done(); iter.Next()) { + std::ostringstream line; + if (iter.Value() < 0 && !opts.allow_negative_labels && !once_only) { + LOG(WARNING) << "Negative symbol table entry when not allowed"; + once_only = true; + } + line << iter.Symbol() << opts.fst_field_separator[0] << iter.Value() + << '\n'; + strm.write(line.str().data(), line.str().length()); + } + return true; +} + +namespace internal { + +DenseSymbolMap::DenseSymbolMap() + : empty_(-1), buckets_(1 << 4), hash_mask_(buckets_.size() - 1) { + std::uninitialized_fill(buckets_.begin(), buckets_.end(), empty_); +} + +DenseSymbolMap::DenseSymbolMap(const DenseSymbolMap &x) + : empty_(-1), + symbols_(x.symbols_.size()), + buckets_(x.buckets_), + hash_mask_(x.hash_mask_) { + for (size_t i = 0; i < symbols_.size(); ++i) { + const auto sz = strlen(x.symbols_[i]) + 1; + auto *cpy = new char[sz]; + memcpy(cpy, x.symbols_[i], sz); + symbols_[i] = cpy; + } +} + +DenseSymbolMap::~DenseSymbolMap() { + for (size_t i = 0; i < symbols_.size(); ++i) { + delete[] symbols_[i]; + } +} + +std::pair DenseSymbolMap::InsertOrFind(const string &key) { + static constexpr float kMaxOccupancyRatio = 0.75; // Grows when 75% full. + if (symbols_.size() >= kMaxOccupancyRatio * buckets_.size()) { + Rehash(buckets_.size() * 2); + } + size_t idx = str_hash_(key) & hash_mask_; + while (buckets_[idx] != empty_) { + const auto stored_value = buckets_[idx]; + if (!strcmp(symbols_[stored_value], key.c_str())) { + return {stored_value, false}; + } + idx = (idx + 1) & hash_mask_; + } + auto next = symbols_.size(); + buckets_[idx] = next; + symbols_.push_back(NewSymbol(key)); + return {next, true}; +} + +int64 DenseSymbolMap::Find(const string &key) const { + size_t idx = str_hash_(key) & hash_mask_; + while (buckets_[idx] != empty_) { + const auto stored_value = buckets_[idx]; + if (!strcmp(symbols_[stored_value], key.c_str())) { + return stored_value; + } + idx = (idx + 1) & hash_mask_; + } + return buckets_[idx]; +} + +void DenseSymbolMap::Rehash(size_t num_buckets) { + buckets_.resize(num_buckets); + hash_mask_ = buckets_.size() - 1; + std::uninitialized_fill(buckets_.begin(), buckets_.end(), empty_); + for (size_t i = 0; i < symbols_.size(); ++i) { + size_t idx = str_hash_(string(symbols_[i])) & hash_mask_; + while (buckets_[idx] != empty_) { + idx = (idx + 1) & hash_mask_; + } + buckets_[idx] = i; + } +} + +const char *DenseSymbolMap::NewSymbol(const string &sym) { + auto num = sym.size() + 1; + auto newstr = new char[num]; + memcpy(newstr, sym.c_str(), num); + return newstr; +} + +void DenseSymbolMap::RemoveSymbol(size_t idx) { + delete[] symbols_[idx]; + symbols_.erase(symbols_.begin() + idx); + Rehash(buckets_.size()); +} + +} // namespace internal + +bool CompatSymbols(const SymbolTable *syms1, const SymbolTable *syms2, + bool warning) { + // Flag can explicitly override this check. + if (!FLAGS_fst_compat_symbols) return true; + if (syms1 && syms2 && + (syms1->LabeledCheckSum() != syms2->LabeledCheckSum())) { + if (warning) { + LOG(WARNING) << "CompatSymbols: Symbol table checksums do not match. " + << "Table sizes are " << syms1->NumSymbols() << " and " + << syms2->NumSymbols(); + } + return false; + } else { + return true; + } +} + +void SymbolTableToString(const SymbolTable *table, string *result) { + std::ostringstream ostrm; + table->Write(ostrm); + *result = ostrm.str(); +} + +SymbolTable *StringToSymbolTable(const string &str) { + std::istringstream istrm(str); + return SymbolTable::Read(istrm, SymbolTableReadOptions()); +} +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/util.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/util.cc new file mode 100644 index 0000000000..bdfd0638a6 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/util.cc @@ -0,0 +1,89 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// FST utility definitions. + +#include +#include +#include +#include +#include +#include +#include + +// Utility flag definitions + +DEFINE_bool(fst_error_fatal, true, + "FST errors are fatal; o.w. return objects flagged as bad: " + "e.g., FSTs: kError property set, FST weights: not a Member()"); + +namespace fst { + +void SplitString(char *full, const char *delim, std::vector *vec, + bool omit_empty_strings) { + char *p = full; + while (p) { + if ((p = strpbrk(full, delim))) { + p[0] = '\0'; + } + if (!omit_empty_strings || full[0] != '\0') vec->push_back(full); + if (p) full = p + 1; + } +} + +int64 StrToInt64(const string &s, const string &src, size_t nline, + bool allow_negative, bool *error) { + int64 n; + const char *cs = s.c_str(); + char *p; + if (error) *error = false; + n = strtoll(cs, &p, 10); + if (p < cs + s.size() || (!allow_negative && n < 0)) { + FSTERROR() << "StrToInt64: Bad integer = " << s << "\", source = " << src + << ", line = " << nline; + if (error) *error = true; + return 0; + } + return n; +} + +void ConvertToLegalCSymbol(string *s) { + for (auto it = s->begin(); it != s->end(); ++it) { + if (!isalnum(*it)) { + *it = '_'; + } + } +} + +// Skips over input characters to align to 'align' bytes. Returns false if can't +// align. +bool AlignInput(std::istream &strm) { + char c; + for (int i = 0; i < MappedFile::kArchAlignment; ++i) { + int64 pos = strm.tellg(); + if (pos < 0) { + LOG(ERROR) << "AlignInput: Can't determine stream position"; + return false; + } + if (pos % MappedFile::kArchAlignment == 0) break; + strm.read(&c, 1); + } + return true; +} + +// Write null output characters to align to 'align' bytes. Returns false if +// can't align. +bool AlignOutput(std::ostream &strm) { + for (int i = 0; i < MappedFile::kArchAlignment; ++i) { + int64 pos = strm.tellp(); + if (pos < 0) { + LOG(ERROR) << "AlignOutput: Can't determine stream position"; + return false; + } + if (pos % MappedFile::kArchAlignment == 0) break; + strm.write("", 1); + } + return true; +} + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/weight.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/weight.cc new file mode 100644 index 0000000000..b34dd0a8d1 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/lib/weight.cc @@ -0,0 +1,117 @@ +#include + +DEFINE_string(fst_weight_separator, ",", + "Character separator between printed composite weights; " + "must be a single character"); + +DEFINE_string(fst_weight_parentheses, "", + "Characters enclosing the first weight of a printed composite " + "weight (e.g., pair weight, tuple weight and derived classes) to " + "ensure proper I/O of nested composite weights; " + "must have size 0 (none) or 2 (open and close parenthesis)"); + +namespace fst { + +namespace internal { + +CompositeWeightIO::CompositeWeightIO(char separator, + std::pair parentheses) + : separator_(separator), + open_paren_(parentheses.first), + close_paren_(parentheses.second), + error_(false) { + if ((open_paren_ == 0 || close_paren_ == 0) && open_paren_ != close_paren_) { + FSTERROR() << "Invalid configuration of weight parentheses: " + << static_cast(open_paren_) << " " + << static_cast(close_paren_); + error_ = true; + } +} + +CompositeWeightIO::CompositeWeightIO() + : CompositeWeightIO(FLAGS_fst_weight_separator.empty() + ? 0 + : FLAGS_fst_weight_separator.front(), + {FLAGS_fst_weight_parentheses.empty() + ? 0 + : FLAGS_fst_weight_parentheses[0], + FLAGS_fst_weight_parentheses.size() < 2 + ? 0 + : FLAGS_fst_weight_parentheses[1]}) { + if (FLAGS_fst_weight_separator.size() != 1) { + FSTERROR() << "CompositeWeight: " + << "FLAGS_fst_weight_separator.size() is not equal to 1"; + error_ = true; + } + if (!FLAGS_fst_weight_parentheses.empty() && + FLAGS_fst_weight_parentheses.size() != 2) { + FSTERROR() << "CompositeWeight: " + << "FLAGS_fst_weight_parentheses.size() is not equal to 2"; + error_ = true; + } +} + +} // namespace internal + +CompositeWeightWriter::CompositeWeightWriter(std::ostream &ostrm) + : ostrm_(ostrm) { + if (error()) ostrm.clear(std::ios::badbit); +} + +CompositeWeightWriter::CompositeWeightWriter(std::ostream &ostrm, + char separator, + std::pair parentheses) + : internal::CompositeWeightIO(separator, parentheses), ostrm_(ostrm) { + if (error()) ostrm_.clear(std::ios::badbit); +} + +void CompositeWeightWriter::WriteBegin() { + if (open_paren_ != 0) { + ostrm_ << open_paren_; + } +} + +void CompositeWeightWriter::WriteEnd() { + if (close_paren_ != 0) { + ostrm_ << close_paren_; + } +} + +CompositeWeightReader::CompositeWeightReader(std::istream &istrm) + : istrm_(istrm) { + if (error()) istrm_.clear(std::ios::badbit); +} + +CompositeWeightReader::CompositeWeightReader(std::istream &istrm, + char separator, + std::pair parentheses) + : internal::CompositeWeightIO(separator, parentheses), istrm_(istrm) { + if (error()) istrm_.clear(std::ios::badbit); +} + +void CompositeWeightReader::ReadBegin() { + do { // Skips whitespace. + c_ = istrm_.get(); + } while (std::isspace(c_)); + if (open_paren_ != 0) { + if (c_ != open_paren_) { + FSTERROR() << "CompositeWeightReader: Open paren missing: " + << "fst_weight_parentheses flag set correcty?"; + istrm_.clear(std::ios::badbit); + return; + } + ++depth_; + c_ = istrm_.get(); + } +} + +void CompositeWeightReader::ReadEnd() { + if (c_ != EOF && !std::isspace(c_)) { + FSTERROR() << "CompositeWeightReader: excess character: '" + << static_cast(c_) + << "': fst_weight_parentheses flag set correcty?"; + istrm_.clear(std::ios::badbit); + } +} + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/Makefile.am b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/Makefile.am new file mode 100644 index 0000000000..2b6d5f94a5 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/Makefile.am @@ -0,0 +1,17 @@ +AM_CPPFLAGS = -I$(srcdir)/../include $(ICU_CPPFLAGS) + +if HAVE_SCRIPT +lib_LTLIBRARIES = libfstscript.la +libfstscript_la_SOURCES = arciterator-class.cc arcsort.cc closure.cc \ +compile.cc compose.cc concat.cc connect.cc convert.cc decode.cc \ +determinize.cc difference.cc disambiguate.cc draw.cc encode.cc \ +encodemapper-class.cc epsnormalize.cc equal.cc equivalent.cc fst-class.cc \ +getters.cc info-impl.cc info.cc intersect.cc invert.cc isomorphic.cc map.cc \ +minimize.cc print.cc project.cc prune.cc push.cc randequivalent.cc \ +randgen.cc relabel.cc replace.cc reverse.cc reweight.cc rmepsilon.cc \ +shortest-distance.cc shortest-path.cc stateiterator-class.cc synchronize.cc \ +text-io.cc topsort.cc union.cc weight-class.cc verify.cc + +libfstscript_la_LIBADD = ../lib/libfst.la -lm $(DL_LIBS) +libfstscript_la_LDFLAGS = -version-info 10:0:0 +endif diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/Makefile.in b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/Makefile.in new file mode 100644 index 0000000000..e423c435f1 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/Makefile.in @@ -0,0 +1,740 @@ +# Makefile.in generated by automake 1.14.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2013 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +VPATH = @srcdir@ +am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +subdir = src/script +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ + $(top_srcdir)/depcomp +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \ + $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ + $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ + $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h \ + $(top_builddir)/src/include/fst/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__uninstall_files_from_dir = { \ + test -z "$$files" \ + || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && rm -f $$files; }; \ + } +am__installdirs = "$(DESTDIR)$(libdir)" +LTLIBRARIES = $(lib_LTLIBRARIES) +am__DEPENDENCIES_1 = +@HAVE_SCRIPT_TRUE@libfstscript_la_DEPENDENCIES = ../lib/libfst.la \ +@HAVE_SCRIPT_TRUE@ $(am__DEPENDENCIES_1) +am__libfstscript_la_SOURCES_DIST = arciterator-class.cc arcsort.cc \ + closure.cc compile.cc compose.cc concat.cc connect.cc \ + convert.cc decode.cc determinize.cc difference.cc \ + disambiguate.cc draw.cc encode.cc encodemapper-class.cc \ + epsnormalize.cc equal.cc equivalent.cc fst-class.cc getters.cc \ + info-impl.cc info.cc intersect.cc invert.cc isomorphic.cc \ + map.cc minimize.cc print.cc project.cc prune.cc push.cc \ + randequivalent.cc randgen.cc relabel.cc replace.cc reverse.cc \ + reweight.cc rmepsilon.cc shortest-distance.cc shortest-path.cc \ + stateiterator-class.cc synchronize.cc text-io.cc topsort.cc \ + union.cc weight-class.cc verify.cc +@HAVE_SCRIPT_TRUE@am_libfstscript_la_OBJECTS = arciterator-class.lo \ +@HAVE_SCRIPT_TRUE@ arcsort.lo closure.lo compile.lo compose.lo \ +@HAVE_SCRIPT_TRUE@ concat.lo connect.lo convert.lo decode.lo \ +@HAVE_SCRIPT_TRUE@ determinize.lo difference.lo disambiguate.lo \ +@HAVE_SCRIPT_TRUE@ draw.lo encode.lo encodemapper-class.lo \ +@HAVE_SCRIPT_TRUE@ epsnormalize.lo equal.lo equivalent.lo \ +@HAVE_SCRIPT_TRUE@ fst-class.lo getters.lo info-impl.lo info.lo \ +@HAVE_SCRIPT_TRUE@ intersect.lo invert.lo isomorphic.lo map.lo \ +@HAVE_SCRIPT_TRUE@ minimize.lo print.lo project.lo prune.lo \ +@HAVE_SCRIPT_TRUE@ push.lo randequivalent.lo randgen.lo \ +@HAVE_SCRIPT_TRUE@ relabel.lo replace.lo reverse.lo reweight.lo \ +@HAVE_SCRIPT_TRUE@ rmepsilon.lo shortest-distance.lo \ +@HAVE_SCRIPT_TRUE@ shortest-path.lo stateiterator-class.lo \ +@HAVE_SCRIPT_TRUE@ synchronize.lo text-io.lo topsort.lo \ +@HAVE_SCRIPT_TRUE@ union.lo weight-class.lo verify.lo +libfstscript_la_OBJECTS = $(am_libfstscript_la_OBJECTS) +AM_V_lt = $(am__v_lt_@AM_V@) +am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) +am__v_lt_0 = --silent +am__v_lt_1 = +libfstscript_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \ + $(AM_CXXFLAGS) $(CXXFLAGS) $(libfstscript_la_LDFLAGS) \ + $(LDFLAGS) -o $@ +@HAVE_SCRIPT_TRUE@am_libfstscript_la_rpath = -rpath $(libdir) +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +DEFAULT_INCLUDES = +depcomp = $(SHELL) $(top_srcdir)/depcomp +am__depfiles_maybe = depfiles +am__mv = mv -f +CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CXXFLAGS) $(CXXFLAGS) +AM_V_CXX = $(am__v_CXX_@AM_V@) +am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@) +am__v_CXX_0 = @echo " CXX " $@; +am__v_CXX_1 = +CXXLD = $(CXX) +CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_CXXLD = $(am__v_CXXLD_@AM_V@) +am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@) +am__v_CXXLD_0 = @echo " CXXLD " $@; +am__v_CXXLD_1 = +SOURCES = $(libfstscript_la_SOURCES) +DIST_SOURCES = $(am__libfstscript_la_SOURCES_DIST) +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DL_LIBS = @DL_LIBS@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PYTHON = @PYTHON@ +PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@ +PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ +PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@ +PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@ +PYTHON_LDFLAGS = @PYTHON_LDFLAGS@ +PYTHON_PLATFORM = @PYTHON_PLATFORM@ +PYTHON_PREFIX = @PYTHON_PREFIX@ +PYTHON_SITE_PKG = @PYTHON_SITE_PKG@ +PYTHON_VERSION = @PYTHON_VERSION@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +libfstdir = @libfstdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgpyexecdir = @pkgpyexecdir@ +pkgpythondir = @pkgpythondir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +pyexecdir = @pyexecdir@ +pythondir = @pythondir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +AM_CPPFLAGS = -I$(srcdir)/../include $(ICU_CPPFLAGS) +@HAVE_SCRIPT_TRUE@lib_LTLIBRARIES = libfstscript.la +@HAVE_SCRIPT_TRUE@libfstscript_la_SOURCES = arciterator-class.cc arcsort.cc closure.cc \ +@HAVE_SCRIPT_TRUE@compile.cc compose.cc concat.cc connect.cc convert.cc decode.cc \ +@HAVE_SCRIPT_TRUE@determinize.cc difference.cc disambiguate.cc draw.cc encode.cc \ +@HAVE_SCRIPT_TRUE@encodemapper-class.cc epsnormalize.cc equal.cc equivalent.cc fst-class.cc \ +@HAVE_SCRIPT_TRUE@getters.cc info-impl.cc info.cc intersect.cc invert.cc isomorphic.cc map.cc \ +@HAVE_SCRIPT_TRUE@minimize.cc print.cc project.cc prune.cc push.cc randequivalent.cc \ +@HAVE_SCRIPT_TRUE@randgen.cc relabel.cc replace.cc reverse.cc reweight.cc rmepsilon.cc \ +@HAVE_SCRIPT_TRUE@shortest-distance.cc shortest-path.cc stateiterator-class.cc synchronize.cc \ +@HAVE_SCRIPT_TRUE@text-io.cc topsort.cc union.cc weight-class.cc verify.cc + +@HAVE_SCRIPT_TRUE@libfstscript_la_LIBADD = ../lib/libfst.la -lm $(DL_LIBS) +@HAVE_SCRIPT_TRUE@libfstscript_la_LDFLAGS = -version-info 10:0:0 +all: all-am + +.SUFFIXES: +.SUFFIXES: .cc .lo .o .obj +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/script/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign src/script/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +install-libLTLIBRARIES: $(lib_LTLIBRARIES) + @$(NORMAL_INSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \ + } + +uninstall-libLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \ + done + +clean-libLTLIBRARIES: + -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES) + @list='$(lib_LTLIBRARIES)'; \ + locs=`for p in $$list; do echo $$p; done | \ + sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ + sort -u`; \ + test -z "$$locs" || { \ + echo rm -f $${locs}; \ + rm -f $${locs}; \ + } + +libfstscript.la: $(libfstscript_la_OBJECTS) $(libfstscript_la_DEPENDENCIES) $(EXTRA_libfstscript_la_DEPENDENCIES) + $(AM_V_CXXLD)$(libfstscript_la_LINK) $(am_libfstscript_la_rpath) $(libfstscript_la_OBJECTS) $(libfstscript_la_LIBADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/arciterator-class.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/arcsort.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/closure.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compile.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compose.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/concat.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/connect.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/convert.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/decode.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/determinize.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/difference.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/disambiguate.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/draw.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/encode.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/encodemapper-class.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/epsnormalize.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/equal.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/equivalent.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fst-class.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/getters.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/info-impl.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/info.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/intersect.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/invert.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isomorphic.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/map.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/minimize.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/print.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/project.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/prune.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/push.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/randequivalent.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/randgen.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/relabel.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/replace.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/reverse.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/reweight.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rmepsilon.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/shortest-distance.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/shortest-path.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/stateiterator-class.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/synchronize.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/text-io.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/topsort.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/union.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/verify.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/weight-class.Plo@am__quote@ + +.cc.o: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $< + +.cc.obj: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cc.lo: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ +@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $< + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-am +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-am + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscopelist: cscopelist-am + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(LTLIBRARIES) +installdirs: + for dir in "$(DESTDIR)$(libdir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \ + mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: install-libLTLIBRARIES + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-libLTLIBRARIES + +.MAKE: install-am install-strip + +.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \ + clean-libLTLIBRARIES clean-libtool cscopelist-am ctags \ + ctags-am distclean distclean-compile distclean-generic \ + distclean-libtool distclean-tags distdir dvi dvi-am html \ + html-am info info-am install install-am install-data \ + install-data-am install-dvi install-dvi-am install-exec \ + install-exec-am install-html install-html-am install-info \ + install-info-am install-libLTLIBRARIES install-man install-pdf \ + install-pdf-am install-ps install-ps-am install-strip \ + installcheck installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-compile \ + mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ + tags tags-am uninstall uninstall-am uninstall-libLTLIBRARIES + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/arciterator-class.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/arciterator-class.cc new file mode 100644 index 0000000000..005b413663 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/arciterator-class.cc @@ -0,0 +1,37 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { +namespace script { + +ArcIteratorClass::ArcIteratorClass(const FstClass &fst, int64 s) + : impl_(nullptr) { + InitArcIteratorClassArgs args(fst, s, this); + Apply>("InitArcIteratorClass", + fst.ArcType(), &args); +} + +MutableArcIteratorClass::MutableArcIteratorClass(MutableFstClass *fst, + int64 s) : impl_(nullptr) { + InitMutableArcIteratorClassArgs args(fst, s, this); + Apply>( + "InitMutableArcIteratorClass", fst->ArcType(), &args); +} + +REGISTER_FST_OPERATION(InitArcIteratorClass, StdArc, InitArcIteratorClassArgs); +REGISTER_FST_OPERATION(InitArcIteratorClass, LogArc, InitArcIteratorClassArgs); +REGISTER_FST_OPERATION(InitArcIteratorClass, Log64Arc, + InitArcIteratorClassArgs); + +REGISTER_FST_OPERATION(InitMutableArcIteratorClass, StdArc, + InitMutableArcIteratorClassArgs); +REGISTER_FST_OPERATION(InitMutableArcIteratorClass, LogArc, + InitMutableArcIteratorClassArgs); +REGISTER_FST_OPERATION(InitMutableArcIteratorClass, Log64Arc, + InitMutableArcIteratorClassArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/arcsort.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/arcsort.cc new file mode 100644 index 0000000000..e7fbeb52df --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/arcsort.cc @@ -0,0 +1,21 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +void ArcSort(MutableFstClass *fst, ArcSortType sort_type) { + ArcSortArgs args(fst, sort_type); + Apply>("ArcSort", fst->ArcType(), &args); +} + +REGISTER_FST_OPERATION(ArcSort, StdArc, ArcSortArgs); +REGISTER_FST_OPERATION(ArcSort, LogArc, ArcSortArgs); +REGISTER_FST_OPERATION(ArcSort, Log64Arc, ArcSortArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/closure.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/closure.cc new file mode 100644 index 0000000000..d8a6788f1e --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/closure.cc @@ -0,0 +1,21 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +void Closure(MutableFstClass *fst, ClosureType closure_type) { + ClosureArgs args(fst, closure_type); + Apply>("Closure", fst->ArcType(), &args); +} + +REGISTER_FST_OPERATION(Closure, StdArc, ClosureArgs); +REGISTER_FST_OPERATION(Closure, LogArc, ClosureArgs); +REGISTER_FST_OPERATION(Closure, Log64Arc, ClosureArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/compile.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/compile.cc new file mode 100644 index 0000000000..0a3c9a55dd --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/compile.cc @@ -0,0 +1,44 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +#include +#include +#include + +namespace fst { +namespace script { + +void CompileFst(std::istream &istrm, const string &source, const string &dest, + const string &fst_type, const string &arc_type, + const SymbolTable *isyms, const SymbolTable *osyms, + const SymbolTable *ssyms, bool accep, bool ikeep, bool okeep, + bool nkeep, bool allow_negative_labels) { + std::unique_ptr fst( + CompileFstInternal(istrm, source, fst_type, arc_type, isyms, osyms, ssyms, + accep, ikeep, okeep, nkeep, allow_negative_labels)); + fst->Write(dest); +} + +FstClass *CompileFstInternal(std::istream &istrm, const string &source, + const string &fst_type, const string &arc_type, + const SymbolTable *isyms, const SymbolTable *osyms, + const SymbolTable *ssyms, bool accep, bool ikeep, + bool okeep, bool nkeep, + bool allow_negative_labels) { + CompileFstInnerArgs iargs(istrm, source, fst_type, isyms, osyms, ssyms, accep, + ikeep, okeep, nkeep, allow_negative_labels); + CompileFstArgs args(iargs); + Apply>("CompileFstInternal", arc_type, &args); + return args.retval; +} + +// This registers 2; 1 does not require registration. +REGISTER_FST_OPERATION(CompileFstInternal, StdArc, CompileFstArgs); +REGISTER_FST_OPERATION(CompileFstInternal, LogArc, CompileFstArgs); +REGISTER_FST_OPERATION(CompileFstInternal, Log64Arc, CompileFstArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/compose.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/compose.cc new file mode 100644 index 0000000000..fcc402869c --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/compose.cc @@ -0,0 +1,27 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +void Compose(const FstClass &ifst1, const FstClass &ifst2, + MutableFstClass *ofst, const ComposeOptions &opts) { + if (!internal::ArcTypesMatch(ifst1, ifst2, "Compose") || + !internal::ArcTypesMatch(*ofst, ifst1, "Compose")) { + ofst->SetProperties(kError, kError); + return; + } + ComposeArgs args(ifst1, ifst2, ofst, opts); + Apply>("Compose", ifst1.ArcType(), &args); +} + +REGISTER_FST_OPERATION(Compose, StdArc, ComposeArgs); +REGISTER_FST_OPERATION(Compose, LogArc, ComposeArgs); +REGISTER_FST_OPERATION(Compose, Log64Arc, ComposeArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/concat.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/concat.cc new file mode 100644 index 0000000000..bdeba8308c --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/concat.cc @@ -0,0 +1,40 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +// 1 +void Concat(MutableFstClass *ofst, const FstClass &ifst) { + if (!internal::ArcTypesMatch(*ofst, ifst, "Concat")) { + ofst->SetProperties(kError, kError); + return; + } + ConcatArgs1 args(ofst, ifst); + Apply>("Concat", ofst->ArcType(), &args); +} + +// 2 +void Concat(const FstClass &ifst, MutableFstClass *ofst) { + if (!internal::ArcTypesMatch(ifst, *ofst, "Concat")) { + ofst->SetProperties(kError, kError); + return; + } + ConcatArgs2 args(ifst, ofst); + Apply>("Concat", ofst->ArcType(), &args); +} + +REGISTER_FST_OPERATION(Concat, StdArc, ConcatArgs1); +REGISTER_FST_OPERATION(Concat, LogArc, ConcatArgs1); +REGISTER_FST_OPERATION(Concat, Log64Arc, ConcatArgs1); + +REGISTER_FST_OPERATION(Concat, StdArc, ConcatArgs2); +REGISTER_FST_OPERATION(Concat, LogArc, ConcatArgs2); +REGISTER_FST_OPERATION(Concat, Log64Arc, ConcatArgs2); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/connect.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/connect.cc new file mode 100644 index 0000000000..6f1ccc22d6 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/connect.cc @@ -0,0 +1,20 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +void Connect(MutableFstClass *fst) { + Apply>("Connect", fst->ArcType(), fst); +} + +REGISTER_FST_OPERATION(Connect, StdArc, MutableFstClass); +REGISTER_FST_OPERATION(Connect, LogArc, MutableFstClass); +REGISTER_FST_OPERATION(Connect, Log64Arc, MutableFstClass); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/convert.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/convert.cc new file mode 100644 index 0000000000..a0d177986a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/convert.cc @@ -0,0 +1,23 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +FstClass *Convert(const FstClass &ifst, const string &new_type) { + ConvertInnerArgs iargs(ifst, new_type); + ConvertArgs args(iargs); + Apply>("Convert", ifst.ArcType(), &args); + return args.retval; +} + +REGISTER_FST_OPERATION(Convert, StdArc, ConvertArgs); +REGISTER_FST_OPERATION(Convert, LogArc, ConvertArgs); +REGISTER_FST_OPERATION(Convert, Log64Arc, ConvertArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/decode.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/decode.cc new file mode 100644 index 0000000000..6ffbf3e2d1 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/decode.cc @@ -0,0 +1,35 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include +#include + +namespace fst { +namespace script { + +void Decode(MutableFstClass *fst, const string &coder_fname) { + DecodeArgs1 args(fst, coder_fname); + Apply>("Decode", fst->ArcType(), &args); +} + +void Decode(MutableFstClass *fst, const EncodeMapperClass &encoder) { + if (!internal::ArcTypesMatch(*fst, encoder, "Decode")) { + fst->SetProperties(kError, kError); + return; + } + DecodeArgs2 args(fst, encoder); + Apply>("Decode", fst->ArcType(), &args); +} + +REGISTER_FST_OPERATION(Decode, StdArc, DecodeArgs1); +REGISTER_FST_OPERATION(Decode, LogArc, DecodeArgs1); +REGISTER_FST_OPERATION(Decode, Log64Arc, DecodeArgs1); + +REGISTER_FST_OPERATION(Decode, StdArc, DecodeArgs2); +REGISTER_FST_OPERATION(Decode, LogArc, DecodeArgs2); +REGISTER_FST_OPERATION(Decode, Log64Arc, DecodeArgs2); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/determinize.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/determinize.cc new file mode 100644 index 0000000000..52bf19a68e --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/determinize.cc @@ -0,0 +1,27 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +void Determinize(const FstClass &ifst, MutableFstClass *ofst, + const DeterminizeOptions &opts) { + if (!internal::ArcTypesMatch(ifst, *ofst, "Determinize") || + !ofst->WeightTypesMatch(opts.weight_threshold, "Determinize")) { + ofst->SetProperties(kError, kError); + return; + } + DeterminizeArgs args(ifst, ofst, opts); + Apply>("Determinize", ifst.ArcType(), &args); +} + +REGISTER_FST_OPERATION(Determinize, StdArc, DeterminizeArgs); +REGISTER_FST_OPERATION(Determinize, LogArc, DeterminizeArgs); +REGISTER_FST_OPERATION(Determinize, Log64Arc, DeterminizeArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/difference.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/difference.cc new file mode 100644 index 0000000000..8161698337 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/difference.cc @@ -0,0 +1,27 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +void Difference(const FstClass &ifst1, const FstClass &ifst2, + MutableFstClass *ofst, const ComposeOptions &opts) { + if (!internal::ArcTypesMatch(ifst1, ifst2, "Difference") || + !internal::ArcTypesMatch(*ofst, ifst1, "Difference")) { + ofst->SetProperties(kError, kError); + return; + } + DifferenceArgs args(ifst1, ifst2, ofst, opts); + Apply>("Difference", ifst1.ArcType(), &args); +} + +REGISTER_FST_OPERATION(Difference, StdArc, DifferenceArgs); +REGISTER_FST_OPERATION(Difference, LogArc, DifferenceArgs); +REGISTER_FST_OPERATION(Difference, Log64Arc, DifferenceArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/disambiguate.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/disambiguate.cc new file mode 100644 index 0000000000..30e0d759ee --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/disambiguate.cc @@ -0,0 +1,27 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +void Disambiguate(const FstClass &ifst, MutableFstClass *ofst, + const DisambiguateOptions &opts) { + if (!internal::ArcTypesMatch(ifst, *ofst, "Disambiguate") || + !ofst->WeightTypesMatch(opts.weight_threshold, "Disambiguate")) { + ofst->SetProperties(kError, kError); + return; + } + DisambiguateArgs args(ifst, ofst, opts); + Apply>("Disambiguate", ifst.ArcType(), &args); +} + +REGISTER_FST_OPERATION(Disambiguate, StdArc, DisambiguateArgs); +REGISTER_FST_OPERATION(Disambiguate, LogArc, DisambiguateArgs); +REGISTER_FST_OPERATION(Disambiguate, Log64Arc, DisambiguateArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/draw.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/draw.cc new file mode 100644 index 0000000000..536c9df053 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/draw.cc @@ -0,0 +1,31 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +#include +#include +#include + +namespace fst { +namespace script { + +void DrawFst(const FstClass &fst, const SymbolTable *isyms, + const SymbolTable *osyms, const SymbolTable *ssyms, bool accep, + const string &title, float width, float height, bool portrait, + bool vertical, float ranksep, float nodesep, int fontsize, + int precision, const string &float_format, bool show_weight_one, + std::ostream *ostrm, const string &dest) { + FstDrawerArgs args(fst, isyms, osyms, ssyms, accep, title, width, height, + portrait, vertical, ranksep, nodesep, fontsize, precision, + float_format, show_weight_one, ostrm, dest); + Apply>("DrawFst", fst.ArcType(), &args); +} + +REGISTER_FST_OPERATION(DrawFst, StdArc, FstDrawerArgs); +REGISTER_FST_OPERATION(DrawFst, LogArc, FstDrawerArgs); +REGISTER_FST_OPERATION(DrawFst, Log64Arc, FstDrawerArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/encode.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/encode.cc new file mode 100644 index 0000000000..4f054504e1 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/encode.cc @@ -0,0 +1,36 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include +#include + +namespace fst { +namespace script { + +void Encode(MutableFstClass *fst, uint32 flags, bool reuse_encoder, + const string &coder_fname) { + EncodeArgs1 args(fst, flags, reuse_encoder, coder_fname); + Apply>("Encode", fst->ArcType(), &args); +} + +void Encode(MutableFstClass *fst, EncodeMapperClass *encoder) { + if (!internal::ArcTypesMatch(*fst, *encoder, "Encode")) { + fst->SetProperties(kError, kError); + return; + } + EncodeArgs2 args(fst, encoder); + Apply>("Encode", fst->ArcType(), &args); +} + +REGISTER_FST_OPERATION(Encode, StdArc, EncodeArgs1); +REGISTER_FST_OPERATION(Encode, LogArc, EncodeArgs1); +REGISTER_FST_OPERATION(Encode, Log64Arc, EncodeArgs1); + +REGISTER_FST_OPERATION(Encode, StdArc, EncodeArgs2); +REGISTER_FST_OPERATION(Encode, LogArc, EncodeArgs2); +REGISTER_FST_OPERATION(Encode, Log64Arc, EncodeArgs2); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/encodemapper-class.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/encodemapper-class.cc new file mode 100644 index 0000000000..f93a468ea7 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/encodemapper-class.cc @@ -0,0 +1,25 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { +namespace script { + +EncodeMapperClass::EncodeMapperClass(const string &arc_type, uint32 flags, + EncodeType type) : impl_(nullptr) { + InitEncodeMapperClassArgs args(flags, type, this); + Apply>("InitEncodeMapperClass", + arc_type, &args); +} + +REGISTER_FST_OPERATION(InitEncodeMapperClass, StdArc, + InitEncodeMapperClassArgs); +REGISTER_FST_OPERATION(InitEncodeMapperClass, LogArc, + InitEncodeMapperClassArgs); +REGISTER_FST_OPERATION(InitEncodeMapperClass, Log64Arc, + InitEncodeMapperClassArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/epsnormalize.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/epsnormalize.cc new file mode 100644 index 0000000000..df799db8b3 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/epsnormalize.cc @@ -0,0 +1,26 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +void EpsNormalize(const FstClass &ifst, MutableFstClass *ofst, + EpsNormalizeType norm_type) { + if (!internal::ArcTypesMatch(ifst, *ofst, "EpsNormalize")) { + ofst->SetProperties(kError, kError); + return; + } + EpsNormalizeArgs args(ifst, ofst, norm_type); + Apply>("EpsNormalize", ifst.ArcType(), &args); +} + +REGISTER_FST_OPERATION(EpsNormalize, StdArc, EpsNormalizeArgs); +REGISTER_FST_OPERATION(EpsNormalize, LogArc, EpsNormalizeArgs); +REGISTER_FST_OPERATION(EpsNormalize, Log64Arc, EpsNormalizeArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/equal.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/equal.cc new file mode 100644 index 0000000000..7d567773fd --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/equal.cc @@ -0,0 +1,24 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +bool Equal(const FstClass &fst1, const FstClass &fst2, float delta) { + if (!internal::ArcTypesMatch(fst1, fst2, "Equal")) return false; + EqualInnerArgs iargs(fst1, fst2, delta); + EqualArgs args(iargs); + Apply>("Equal", fst1.ArcType(), &args); + return args.retval; +} + +REGISTER_FST_OPERATION(Equal, StdArc, EqualArgs); +REGISTER_FST_OPERATION(Equal, LogArc, EqualArgs); +REGISTER_FST_OPERATION(Equal, Log64Arc, EqualArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/equivalent.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/equivalent.cc new file mode 100644 index 0000000000..10bc1e7ec2 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/equivalent.cc @@ -0,0 +1,24 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +bool Equivalent(const FstClass &fst1, const FstClass &fst2, float delta) { + if (!internal::ArcTypesMatch(fst1, fst2, "Equivalent")) return false; + EquivalentInnerArgs iargs(fst1, fst2, delta); + EquivalentArgs args(iargs); + Apply>("Equivalent", fst1.ArcType(), &args); + return args.retval; +} + +REGISTER_FST_OPERATION(Equivalent, StdArc, EquivalentArgs); +REGISTER_FST_OPERATION(Equivalent, LogArc, EquivalentArgs); +REGISTER_FST_OPERATION(Equivalent, Log64Arc, EquivalentArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/fst-class.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/fst-class.cc new file mode 100644 index 0000000000..50fb610ca6 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/fst-class.cc @@ -0,0 +1,126 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// These classes are only recommended for use in high-level scripting +// applications. Most users should use the lower-level templated versions +// corresponding to these classes. + +#include + +#include + +#include +#include +#include +#include +#include +#include + +namespace fst { +namespace script { + +// Registration. + +REGISTER_FST_CLASSES(StdArc); +REGISTER_FST_CLASSES(LogArc); +REGISTER_FST_CLASSES(Log64Arc); + +// FstClass methods. + +namespace { + +template +F *ReadFst(std::istream &istrm, const string &fname) { + if (!istrm) { + LOG(ERROR) << "ReadFst: Can't open file: " << fname; + return nullptr; + } + FstHeader hdr; + if (!hdr.Read(istrm, fname)) return nullptr; + const FstReadOptions read_options(fname, &hdr); + const auto &arc_type = hdr.ArcType(); + static const auto *io_register = IORegistration::Register::GetRegister(); + const auto reader = io_register->GetReader(arc_type); + if (!reader) { + LOG(ERROR) << "ReadFst: Unknown arc type: " << arc_type; + return nullptr; + } + return reader(istrm, read_options); +} + +} // namespace + +FstClass *FstClass::Read(const string &fname) { + if (!fname.empty()) { + std::ifstream istrm(fname, std::ios_base::in | std::ios_base::binary); + return ReadFst(istrm, fname); + } else { + return ReadFst(std::cin, "standard input"); + } +} + +FstClass *FstClass::Read(std::istream &istrm, const string &source) { + return ReadFst(istrm, source); +} + +bool FstClass::WeightTypesMatch(const WeightClass &weight, + const string &op_name) const { + if (WeightType() != weight.Type()) { + FSTERROR() << "FST and weight with non-matching weight types passed to " + << op_name << ": " << WeightType() << " and " << weight.Type(); + return false; + } + return true; +} + +// MutableFstClass methods. + +MutableFstClass *MutableFstClass::Read(const string &fname, bool convert) { + if (convert == false) { + if (!fname.empty()) { + std::ifstream in(fname, std::ios_base::in | std::ios_base::binary); + return ReadFst(in, fname); + } else { + return ReadFst(std::cin, "standard input"); + } + } else { // Converts to VectorFstClass if not mutable. + std::unique_ptr ifst(FstClass::Read(fname)); + if (!ifst) return nullptr; + if (ifst->Properties(kMutable, false) == kMutable) { + return static_cast(ifst.release()); + } else { + return new VectorFstClass(*ifst.release()); + } + } +} + +// VectorFstClass methods. + +VectorFstClass *VectorFstClass::Read(const string &fname) { + if (!fname.empty()) { + std::ifstream in(fname, std::ios_base::in | std::ios_base::binary); + return ReadFst(in, fname); + } else { + return ReadFst(std::cin, "standard input"); + } +} + +IORegistration::Entry GetVFSTRegisterEntry( + const string &arc_type) { + static const auto *io_register = + IORegistration::Register::GetRegister(); + return io_register->GetEntry(arc_type); +} + +VectorFstClass::VectorFstClass(const string &arc_type) + : MutableFstClass(GetVFSTRegisterEntry(arc_type).creator()) { + if (Properties(kError, true) == kError) { + FSTERROR() << "VectorFstClass: Unknown arc type: " << arc_type; + } +} + +VectorFstClass::VectorFstClass(const FstClass &other) + : MutableFstClass(GetVFSTRegisterEntry(other.ArcType()).converter(other)) {} + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/getters.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/getters.cc new file mode 100644 index 0000000000..331e894f79 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/getters.cc @@ -0,0 +1,135 @@ +#include + +namespace fst { +namespace script { + +bool GetArcSortType(const string &str, ArcSortType *sort_type) { + if (str == "ilabel") { + *sort_type = ILABEL_SORT; + } else if (str == "olabel") { + *sort_type = OLABEL_SORT; + } else { + return false; + } + return true; +} + +bool GetComposeFilter(const string &str, ComposeFilter *compose_filter) { + if (str == "alt_sequence") { + *compose_filter = ALT_SEQUENCE_FILTER; + } else if (str == "auto") { + *compose_filter = AUTO_FILTER; + } else if (str == "match") { + *compose_filter = MATCH_FILTER; + } else if (str == "null") { + *compose_filter = NULL_FILTER; + } else if (str == "sequence") { + *compose_filter = SEQUENCE_FILTER; + } else if (str == "trivial") { + *compose_filter = TRIVIAL_FILTER; + } else { + return false; + } + return true; +} + +bool GetDeterminizeType(const string &str, DeterminizeType *det_type) { + if (str == "functional") { + *det_type = DETERMINIZE_FUNCTIONAL; + } else if (str == "nonfunctional") { + *det_type = DETERMINIZE_NONFUNCTIONAL; + } else if (str == "disambiguate") { + *det_type = DETERMINIZE_DISAMBIGUATE; + } else { + return false; + } + return true; +} + +bool GetMapType(const string &str, MapType *map_type) { + if (str == "arc_sum") { + *map_type = ARC_SUM_MAPPER; + } else if (str == "arc_unique") { + *map_type = ARC_UNIQUE_MAPPER; + } else if (str == "identity") { + *map_type = IDENTITY_MAPPER; + } else if (str == "input_epsilon") { + *map_type = INPUT_EPSILON_MAPPER; + } else if (str == "invert") { + *map_type = INVERT_MAPPER; + } else if (str == "output_epsilon") { + *map_type = OUTPUT_EPSILON_MAPPER; + } else if (str == "plus") { + *map_type = PLUS_MAPPER; + } else if (str == "power") { + *map_type = POWER_MAPPER; + } else if (str == "quantize") { + *map_type = QUANTIZE_MAPPER; + } else if (str == "rmweight") { + *map_type = RMWEIGHT_MAPPER; + } else if (str == "superfinal") { + *map_type = SUPERFINAL_MAPPER; + } else if (str == "times") { + *map_type = TIMES_MAPPER; + } else if (str == "to_log") { + *map_type = TO_LOG_MAPPER; + } else if (str == "to_log64") { + *map_type = TO_LOG64_MAPPER; + } else if (str == "to_std" || str == "to_standard") { + *map_type = TO_STD_MAPPER; + } else { + return false; + } + return true; +} + +bool GetRandArcSelection(const string &str, RandArcSelection *ras) { + if (str == "uniform") { + *ras = UNIFORM_ARC_SELECTOR; + } else if (str == "log_prob") { + *ras = LOG_PROB_ARC_SELECTOR; + } else if (str == "fast_log_prob") { + *ras = FAST_LOG_PROB_ARC_SELECTOR; + } else { + return false; + } + return true; +} + +bool GetQueueType(const string &str, QueueType *queue_type) { + if (str == "auto") { + *queue_type = AUTO_QUEUE; + } else if (str == "fifo") { + *queue_type = FIFO_QUEUE; + } else if (str == "lifo") { + *queue_type = LIFO_QUEUE; + } else if (str == "shortest") { + *queue_type = SHORTEST_FIRST_QUEUE; + } else if (str == "state") { + *queue_type = STATE_ORDER_QUEUE; + } else if (str == "top") { + *queue_type = TOP_ORDER_QUEUE; + } else { + return false; + } + return true; +} + +bool GetReplaceLabelType(const string &str, bool epsilon_on_replace, + ReplaceLabelType *rlt) { + if (epsilon_on_replace || str == "neither") { + *rlt = REPLACE_LABEL_NEITHER; + } else if (str == "input") { + *rlt = REPLACE_LABEL_INPUT; + } else if (str == "output") { + *rlt = REPLACE_LABEL_OUTPUT; + } else if (str == "both") { + *rlt = REPLACE_LABEL_BOTH; + } else { + return false; + } + return true; +} + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/info-impl.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/info-impl.cc new file mode 100644 index 0000000000..1d7c9bb9be --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/info-impl.cc @@ -0,0 +1,101 @@ +#include + +namespace fst { + +void PrintFstInfoImpl(const FstInfo &fstinfo, bool pipe) { + std::ostream &ostrm = pipe ? std::cerr : std::cout; + const auto old = ostrm.setf(std::ios::left); + ostrm.width(50); + ostrm << "fst type" << fstinfo.FstType() << std::endl; + ostrm.width(50); + ostrm << "arc type" << fstinfo.ArcType() << std::endl; + ostrm.width(50); + ostrm << "input symbol table" << fstinfo.InputSymbols() << std::endl; + ostrm.width(50); + ostrm << "output symbol table" << fstinfo.OutputSymbols() << std::endl; + if (!fstinfo.LongInfo()) { + ostrm.setf(old); + return; + } + ostrm.width(50); + ostrm << "# of states" << fstinfo.NumStates() << std::endl; + ostrm.width(50); + ostrm << "# of arcs" << fstinfo.NumArcs() << std::endl; + ostrm.width(50); + ostrm << "initial state" << fstinfo.Start() << std::endl; + ostrm.width(50); + ostrm << "# of final states" << fstinfo.NumFinal() << std::endl; + ostrm.width(50); + ostrm << "# of input/output epsilons" << fstinfo.NumEpsilons() << std::endl; + ostrm.width(50); + ostrm << "# of input epsilons" << fstinfo.NumInputEpsilons() << std::endl; + ostrm.width(50); + ostrm << "# of output epsilons" << fstinfo.NumOutputEpsilons() << std::endl; + ostrm.width(50); + ostrm << "input label multiplicity" << fstinfo.InputLabelMultiplicity() + << std::endl; + ostrm.width(50); + ostrm << "output label multiplicity" << fstinfo.OutputLabelMultiplicity() + << std::endl; + ostrm.width(50); + string arc_type = ""; + if (fstinfo.ArcFilterType() == "epsilon") + arc_type = "epsilon "; + else if (fstinfo.ArcFilterType() == "iepsilon") + arc_type = "input-epsilon "; + else if (fstinfo.ArcFilterType() == "oepsilon") + arc_type = "output-epsilon "; + const auto accessible_label = "# of " + arc_type + "accessible states"; + ostrm.width(50); + ostrm << accessible_label << fstinfo.NumAccessible() << std::endl; + const auto coaccessible_label = "# of " + arc_type + "coaccessible states"; + ostrm.width(50); + ostrm << coaccessible_label << fstinfo.NumCoAccessible() << std::endl; + const auto connected_label = "# of " + arc_type + "connected states"; + ostrm.width(50); + ostrm << connected_label << fstinfo.NumConnected() << std::endl; + const auto numcc_label = "# of " + arc_type + "connected components"; + ostrm.width(50); + ostrm << numcc_label << fstinfo.NumCc() << std::endl; + const auto numscc_label = "# of " + arc_type + "strongly conn components"; + ostrm.width(50); + ostrm << numscc_label << fstinfo.NumScc() << std::endl; + ostrm.width(50); + ostrm << "input matcher" + << (fstinfo.InputMatchType() == MATCH_INPUT + ? 'y' + : fstinfo.InputMatchType() == MATCH_NONE ? 'n' : '?') + << std::endl; + ostrm.width(50); + ostrm << "output matcher" + << (fstinfo.OutputMatchType() == MATCH_OUTPUT + ? 'y' + : fstinfo.OutputMatchType() == MATCH_NONE ? 'n' : '?') + << std::endl; + ostrm.width(50); + ostrm << "input lookahead" << (fstinfo.InputLookAhead() ? 'y' : 'n') + << std::endl; + ostrm.width(50); + ostrm << "output lookahead" << (fstinfo.OutputLookAhead() ? 'y' : 'n') + << std::endl; + uint64 prop = 1; + for (auto i = 0; i < 64; ++i, prop <<= 1) { + if (prop & kBinaryProperties) { + char value = 'n'; + if (fstinfo.Properties() & prop) value = 'y'; + ostrm.width(50); + ostrm << PropertyNames[i] << value << std::endl; + } else if (prop & kPosTrinaryProperties) { + char value = '?'; + if (fstinfo.Properties() & prop) + value = 'y'; + else if (fstinfo.Properties() & prop << 1) + value = 'n'; + ostrm.width(50); + ostrm << PropertyNames[i] << value << std::endl; + } + } + ostrm.setf(old); +} + +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/info.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/info.cc new file mode 100644 index 0000000000..4af5117045 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/info.cc @@ -0,0 +1,36 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +#include +#include +#include + +namespace fst { +namespace script { + +void PrintFstInfo(const FstClass &fst, bool test_properties, + const string &arc_filter, const string &info_type, bool pipe, + bool verify) { + InfoArgs args(fst, test_properties, arc_filter, info_type, pipe, verify); + Apply>("PrintFstInfo", fst.ArcType(), &args); +} + +void GetFstInfo(const FstClass &fst, bool test_properties, + const string &arc_filter, const string &info_type, bool verify, + FstInfo *result) { + GetInfoArgs args(fst, test_properties, arc_filter, info_type, verify, result); + Apply>("GetFstInfo", fst.ArcType(), &args); +} + +REGISTER_FST_OPERATION(PrintFstInfo, StdArc, InfoArgs); +REGISTER_FST_OPERATION(PrintFstInfo, LogArc, InfoArgs); +REGISTER_FST_OPERATION(PrintFstInfo, Log64Arc, InfoArgs); + +REGISTER_FST_OPERATION(GetFstInfo, StdArc, GetInfoArgs); +REGISTER_FST_OPERATION(GetFstInfo, LogArc, GetInfoArgs); +REGISTER_FST_OPERATION(GetFstInfo, Log64Arc, GetInfoArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/intersect.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/intersect.cc new file mode 100644 index 0000000000..123b019447 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/intersect.cc @@ -0,0 +1,27 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +void Intersect(const FstClass &ifst1, const FstClass &ifst2, + MutableFstClass *ofst, const ComposeOptions &opts) { + if (!internal::ArcTypesMatch(ifst1, ifst2, "Intersect") || + !internal::ArcTypesMatch(*ofst, ifst1, "Intersect")) { + ofst->SetProperties(kError, kError); + return; + } + IntersectArgs args(ifst1, ifst2, ofst, opts); + Apply>("Intersect", ifst1.ArcType(), &args); +} + +REGISTER_FST_OPERATION(Intersect, StdArc, IntersectArgs); +REGISTER_FST_OPERATION(Intersect, LogArc, IntersectArgs); +REGISTER_FST_OPERATION(Intersect, Log64Arc, IntersectArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/invert.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/invert.cc new file mode 100644 index 0000000000..1dcc68cd29 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/invert.cc @@ -0,0 +1,20 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +void Invert(MutableFstClass *fst) { + Apply>("Invert", fst->ArcType(), fst); +} + +REGISTER_FST_OPERATION(Invert, StdArc, MutableFstClass); +REGISTER_FST_OPERATION(Invert, LogArc, MutableFstClass); +REGISTER_FST_OPERATION(Invert, Log64Arc, MutableFstClass); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/isomorphic.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/isomorphic.cc new file mode 100644 index 0000000000..4d89df4322 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/isomorphic.cc @@ -0,0 +1,24 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +bool Isomorphic(const FstClass &fst1, const FstClass &fst2, float delta) { + if (!internal::ArcTypesMatch(fst1, fst2, "Isomorphic")) return false; + IsomorphicInnerArgs iargs(fst1, fst2, delta); + IsomorphicArgs args(iargs); + Apply>("Isomorphic", fst1.ArcType(), &args); + return args.retval; +} + +REGISTER_FST_OPERATION(Isomorphic, StdArc, IsomorphicArgs); +REGISTER_FST_OPERATION(Isomorphic, LogArc, IsomorphicArgs); +REGISTER_FST_OPERATION(Isomorphic, Log64Arc, IsomorphicArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/map.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/map.cc new file mode 100644 index 0000000000..45ef38073b --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/map.cc @@ -0,0 +1,25 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +FstClass *Map(const FstClass &ifst, MapType map_type, float delta, double power, + const WeightClass &weight) { + if (!ifst.WeightTypesMatch(weight, "Map")) return nullptr; + MapInnerArgs iargs(ifst, map_type, delta, power, weight); + MapArgs args(iargs); + Apply>("Map", ifst.ArcType(), &args); + return args.retval; +} + +REGISTER_FST_OPERATION(Map, StdArc, MapArgs); +REGISTER_FST_OPERATION(Map, LogArc, MapArgs); +REGISTER_FST_OPERATION(Map, Log64Arc, MapArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/minimize.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/minimize.cc new file mode 100644 index 0000000000..9c4e59c74f --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/minimize.cc @@ -0,0 +1,27 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +void Minimize(MutableFstClass *ofst1, MutableFstClass *ofst2, float delta, + bool allow_nondet) { + if (ofst2 && !internal::ArcTypesMatch(*ofst1, *ofst2, "Minimize")) { + ofst1->SetProperties(kError, kError); + ofst2->SetProperties(kError, kError); + return; + } + MinimizeArgs args(ofst1, ofst2, delta, allow_nondet); + Apply>("Minimize", ofst1->ArcType(), &args); +} + +REGISTER_FST_OPERATION(Minimize, StdArc, MinimizeArgs); +REGISTER_FST_OPERATION(Minimize, LogArc, MinimizeArgs); +REGISTER_FST_OPERATION(Minimize, Log64Arc, MinimizeArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/print.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/print.cc new file mode 100644 index 0000000000..df28dac318 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/print.cc @@ -0,0 +1,29 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +#include +#include +#include + +namespace fst { +namespace script { + +void PrintFst(const FstClass &fst, std::ostream &ostrm, const string &dest, + const SymbolTable *isyms, const SymbolTable *osyms, + const SymbolTable *ssyms, bool accept, bool show_weight_one, + const string &missing_sym) { + const auto sep = FLAGS_fst_field_separator.substr(0, 1); + FstPrinterArgs args(fst, isyms, osyms, ssyms, accept, show_weight_one, &ostrm, + dest, sep, missing_sym); + Apply>("PrintFst", fst.ArcType(), &args); +} + +REGISTER_FST_OPERATION(PrintFst, StdArc, FstPrinterArgs); +REGISTER_FST_OPERATION(PrintFst, LogArc, FstPrinterArgs); +REGISTER_FST_OPERATION(PrintFst, Log64Arc, FstPrinterArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/project.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/project.cc new file mode 100644 index 0000000000..32678a006e --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/project.cc @@ -0,0 +1,22 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + + +void Project(MutableFstClass *ofst, ProjectType project_type) { + ProjectArgs args(ofst, project_type); + Apply>("Project", ofst->ArcType(), &args); +} + +REGISTER_FST_OPERATION(Project, StdArc, ProjectArgs); +REGISTER_FST_OPERATION(Project, LogArc, ProjectArgs); +REGISTER_FST_OPERATION(Project, Log64Arc, ProjectArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/prune.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/prune.cc new file mode 100644 index 0000000000..37862e23d2 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/prune.cc @@ -0,0 +1,42 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +void Prune(const FstClass &ifst, MutableFstClass *ofst, + const WeightClass &weight_threshold, + int64 state_threshold, float delta) { + if (!internal::ArcTypesMatch(ifst, *ofst, "Prune") || + !ofst->WeightTypesMatch(weight_threshold, "Prune")) { + ofst->SetProperties(kError, kError); + return; + } + PruneArgs1 args(ifst, ofst, weight_threshold, state_threshold, delta); + Apply>("Prune", ifst.ArcType(), &args); +} + +void Prune(MutableFstClass *fst, const WeightClass &weight_threshold, + int64 state_threshold, float delta) { + if (!fst->WeightTypesMatch(weight_threshold, "Prune")) { + fst->SetProperties(kError, kError); + return; + } + PruneArgs2 args(fst, weight_threshold, state_threshold, delta); + Apply>("Prune", fst->ArcType(), &args); +} + +REGISTER_FST_OPERATION(Prune, StdArc, PruneArgs1); +REGISTER_FST_OPERATION(Prune, LogArc, PruneArgs1); +REGISTER_FST_OPERATION(Prune, Log64Arc, PruneArgs1); + +REGISTER_FST_OPERATION(Prune, StdArc, PruneArgs2); +REGISTER_FST_OPERATION(Prune, LogArc, PruneArgs2); +REGISTER_FST_OPERATION(Prune, Log64Arc, PruneArgs2); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/push.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/push.cc new file mode 100644 index 0000000000..5b9dbea236 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/push.cc @@ -0,0 +1,36 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +void Push(MutableFstClass *fst, ReweightType rew_type, float delta, + bool remove_total_weight) { + PushArgs1 args(fst, rew_type, delta, remove_total_weight); + Apply>("Push", fst->ArcType(), &args); +} + +void Push(const FstClass &ifst, MutableFstClass *ofst, uint32 flags, + ReweightType rew_type, float delta) { + if (!internal::ArcTypesMatch(ifst, *ofst, "Push")) { + ofst->SetProperties(kError, kError); + return; + } + PushArgs2 args(ifst, ofst, flags, rew_type, delta); + Apply>("Push", ifst.ArcType(), &args); +} + +REGISTER_FST_OPERATION(Push, StdArc, PushArgs1); +REGISTER_FST_OPERATION(Push, LogArc, PushArgs1); +REGISTER_FST_OPERATION(Push, Log64Arc, PushArgs1); + +REGISTER_FST_OPERATION(Push, StdArc, PushArgs2); +REGISTER_FST_OPERATION(Push, LogArc, PushArgs2); +REGISTER_FST_OPERATION(Push, Log64Arc, PushArgs2); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/randequivalent.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/randequivalent.cc new file mode 100644 index 0000000000..3fa518e8ee --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/randequivalent.cc @@ -0,0 +1,26 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +bool RandEquivalent(const FstClass &fst1, const FstClass &fst2, int32 npath, + float delta, time_t seed, + const RandGenOptions &opts) { + if (!internal::ArcTypesMatch(fst1, fst2, "RandEquivalent")) return false; + RandEquivalentInnerArgs iargs(fst1, fst2, npath, delta, seed, opts); + RandEquivalentArgs args(iargs); + Apply>("RandEquivalent", fst1.ArcType(), &args); + return args.retval; +} + +REGISTER_FST_OPERATION(RandEquivalent, StdArc, RandEquivalentArgs); +REGISTER_FST_OPERATION(RandEquivalent, LogArc, RandEquivalentArgs); +REGISTER_FST_OPERATION(RandEquivalent, Log64Arc, RandEquivalentArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/randgen.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/randgen.cc new file mode 100644 index 0000000000..4da59ae2f5 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/randgen.cc @@ -0,0 +1,26 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +void RandGen(const FstClass &ifst, MutableFstClass *ofst, time_t seed, + const RandGenOptions &opts) { + if (!internal::ArcTypesMatch(ifst, *ofst, "RandGen")) { + ofst->SetProperties(kError, kError); + return; + } + RandGenArgs args(ifst, ofst, seed, opts); + Apply>("RandGen", ifst.ArcType(), &args); +} + +REGISTER_FST_OPERATION(RandGen, StdArc, RandGenArgs); +REGISTER_FST_OPERATION(RandGen, LogArc, RandGenArgs); +REGISTER_FST_OPERATION(RandGen, Log64Arc, RandGenArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/relabel.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/relabel.cc new file mode 100644 index 0000000000..a2be47ceab --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/relabel.cc @@ -0,0 +1,37 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +void Relabel(MutableFstClass *ofst, + const SymbolTable *old_isyms, const SymbolTable *relabel_isyms, + const string &unknown_isymbol, bool attach_new_isyms, + const SymbolTable *old_osyms, const SymbolTable *relabel_osyms, + const string &unknown_osymbol, bool attach_new_osyms) { + RelabelArgs1 args(ofst, old_isyms, relabel_isyms, unknown_isymbol, + attach_new_isyms, old_osyms, relabel_osyms, + unknown_osymbol, attach_new_osyms); + Apply>("Relabel", ofst->ArcType(), &args); +} + +void Relabel(MutableFstClass *ofst, const std::vector &ipairs, + const std::vector &opairs) { + RelabelArgs2 args(ofst, ipairs, opairs); + Apply>("Relabel", ofst->ArcType(), &args); +} + +REGISTER_FST_OPERATION(Relabel, StdArc, RelabelArgs1); +REGISTER_FST_OPERATION(Relabel, LogArc, RelabelArgs1); +REGISTER_FST_OPERATION(Relabel, Log64Arc, RelabelArgs1); + +REGISTER_FST_OPERATION(Relabel, StdArc, RelabelArgs2); +REGISTER_FST_OPERATION(Relabel, LogArc, RelabelArgs2); +REGISTER_FST_OPERATION(Relabel, Log64Arc, RelabelArgs2); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/replace.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/replace.cc new file mode 100644 index 0000000000..3a92120a59 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/replace.cc @@ -0,0 +1,34 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +void Replace(const std::vector &pairs, MutableFstClass *ofst, + const ReplaceOptions &opts) { + if (!pairs.empty()) { + for (auto it = pairs.begin(); it != pairs.end() - 1; ++it) { + if (!internal::ArcTypesMatch(*it->second, *(it + 1)->second, "Replace")) { + ofst->SetProperties(kError, kError); + return; + } + } + if (!internal::ArcTypesMatch(*pairs[0].second, *ofst, "Replace")) { + ofst->SetProperties(kError, kError); + return; + } + } + ReplaceArgs args(pairs, ofst, opts); + Apply>("Replace", ofst->ArcType(), &args); +} + +REGISTER_FST_OPERATION(Replace, StdArc, ReplaceArgs); +REGISTER_FST_OPERATION(Replace, LogArc, ReplaceArgs); +REGISTER_FST_OPERATION(Replace, Log64Arc, ReplaceArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/reverse.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/reverse.cc new file mode 100644 index 0000000000..e403b79098 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/reverse.cc @@ -0,0 +1,26 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +void Reverse(const FstClass &ifst, MutableFstClass *ofst, + bool require_superinitial) { + if (!internal::ArcTypesMatch(ifst, *ofst, "Reverse")) { + ofst->SetProperties(kError, kError); + return; + } + ReverseArgs args(ifst, ofst, require_superinitial); + Apply>("Reverse", ifst.ArcType(), &args); +} + +REGISTER_FST_OPERATION(Reverse, StdArc, ReverseArgs); +REGISTER_FST_OPERATION(Reverse, LogArc, ReverseArgs); +REGISTER_FST_OPERATION(Reverse, Log64Arc, ReverseArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/reweight.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/reweight.cc new file mode 100644 index 0000000000..c2306a1656 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/reweight.cc @@ -0,0 +1,22 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +void Reweight(MutableFstClass *fst, const std::vector &potential, + ReweightType reweight_type) { + ReweightArgs args(fst, potential, reweight_type); + Apply>("Reweight", fst->ArcType(), &args); +} + +REGISTER_FST_OPERATION(Reweight, StdArc, ReweightArgs); +REGISTER_FST_OPERATION(Reweight, LogArc, ReweightArgs); +REGISTER_FST_OPERATION(Reweight, Log64Arc, ReweightArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/rmepsilon.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/rmepsilon.cc new file mode 100644 index 0000000000..6808990e5b --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/rmepsilon.cc @@ -0,0 +1,25 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +void RmEpsilon(MutableFstClass *fst, const RmEpsilonOptions &opts) { + if (!fst->WeightTypesMatch(opts.weight_threshold, "RmEpsilon")) { + fst->SetProperties(kError, kError); + return; + } + RmEpsilonArgs args(fst, opts); + Apply>("RmEpsilon", fst->ArcType(), &args); +} + +REGISTER_FST_OPERATION(RmEpsilon, StdArc, RmEpsilonArgs); +REGISTER_FST_OPERATION(RmEpsilon, LogArc, RmEpsilonArgs); +REGISTER_FST_OPERATION(RmEpsilon, Log64Arc, RmEpsilonArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/shortest-distance.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/shortest-distance.cc new file mode 100644 index 0000000000..080e29de0a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/shortest-distance.cc @@ -0,0 +1,34 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +void ShortestDistance(const FstClass &fst, std::vector *distance, + const ShortestDistanceOptions &opts) { + ShortestDistanceArgs1 args(fst, distance, opts); + Apply>("ShortestDistance", fst.ArcType(), + &args); +} + +void ShortestDistance(const FstClass &ifst, std::vector *distance, + bool reverse, double delta) { + ShortestDistanceArgs2 args(ifst, distance, reverse, delta); + Apply>("ShortestDistance", ifst.ArcType(), + &args); +} + +REGISTER_FST_OPERATION(ShortestDistance, StdArc, ShortestDistanceArgs1); +REGISTER_FST_OPERATION(ShortestDistance, LogArc, ShortestDistanceArgs1); +REGISTER_FST_OPERATION(ShortestDistance, Log64Arc, ShortestDistanceArgs1); + +REGISTER_FST_OPERATION(ShortestDistance, StdArc, ShortestDistanceArgs2); +REGISTER_FST_OPERATION(ShortestDistance, LogArc, ShortestDistanceArgs2); +REGISTER_FST_OPERATION(ShortestDistance, Log64Arc, ShortestDistanceArgs2); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/shortest-path.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/shortest-path.cc new file mode 100644 index 0000000000..cbbda63173 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/shortest-path.cc @@ -0,0 +1,26 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +void ShortestPath(const FstClass &ifst, MutableFstClass *ofst, + const ShortestPathOptions &opts) { + if (!internal::ArcTypesMatch(ifst, *ofst, "ShortestPath")) { + ofst->SetProperties(kError, kError); + return; + } + ShortestPathArgs args(ifst, ofst, opts); + Apply>("ShortestPath", ifst.ArcType(), &args); +} + +REGISTER_FST_OPERATION(ShortestPath, StdArc, ShortestPathArgs); +REGISTER_FST_OPERATION(ShortestPath, LogArc, ShortestPathArgs); +REGISTER_FST_OPERATION(ShortestPath, Log64Arc, ShortestPathArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/stateiterator-class.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/stateiterator-class.cc new file mode 100644 index 0000000000..7bacd926b9 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/stateiterator-class.cc @@ -0,0 +1,24 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include + +namespace fst { +namespace script { + +StateIteratorClass::StateIteratorClass(const FstClass &fst) : impl_(nullptr) { + InitStateIteratorClassArgs args(fst, this); + Apply>("InitStateIteratorClass", + fst.ArcType(), &args); +} + +REGISTER_FST_OPERATION(InitStateIteratorClass, StdArc, + InitStateIteratorClassArgs); +REGISTER_FST_OPERATION(InitStateIteratorClass, LogArc, + InitStateIteratorClassArgs); +REGISTER_FST_OPERATION(InitStateIteratorClass, Log64Arc, + InitStateIteratorClassArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/synchronize.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/synchronize.cc new file mode 100644 index 0000000000..9599a3ac4a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/synchronize.cc @@ -0,0 +1,25 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +void Synchronize(const FstClass &ifst, MutableFstClass *ofst) { + if (!internal::ArcTypesMatch(ifst, *ofst, "Synchronize")) { + ofst->SetProperties(kError, kError); + return; + } + SynchronizeArgs args(ifst, ofst); + Apply>("Synchronize", ifst.ArcType(), &args); +} + +REGISTER_FST_OPERATION(Synchronize, StdArc, SynchronizeArgs); +REGISTER_FST_OPERATION(Synchronize, LogArc, SynchronizeArgs); +REGISTER_FST_OPERATION(Synchronize, Log64Arc, SynchronizeArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/text-io.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/text-io.cc new file mode 100644 index 0000000000..a7be72103a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/text-io.cc @@ -0,0 +1,76 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +#include +#include +#include +#include +#include + +#include +#include +#include + +namespace fst { +namespace script { + +// Reads vector of weights; returns true on success. +bool ReadPotentials(const string &weight_type, const string &filename, + std::vector *potentials) { + std::ifstream istrm(filename); + if (!istrm.good()) { + LOG(ERROR) << "ReadPotentials: Can't open file: " << filename; + return false; + } + static constexpr int kLineLen = 8096; + char line[kLineLen]; + size_t nline = 0; + potentials->clear(); + while (!istrm.getline(line, kLineLen).fail()) { + ++nline; + std::vector col; + SplitString(line, "\n\t ", &col, true); + if (col.empty() || col[0][0] == '\0') continue; + if (col.size() != 2) { + FSTERROR() << "ReadPotentials: Bad number of columns, " + << "file = " << filename << ", line = " << nline; + return false; + } + const ssize_t s = StrToInt64(col[0], filename, nline, false); + const WeightClass weight(weight_type, col[1]); + while (potentials->size() <= s) { + potentials->push_back(WeightClass::Zero(weight_type)); + } + potentials->back() = weight; + } + return true; +} + +// Writes vector of weights; returns true on success. +bool WritePotentials(const string &filename, + const std::vector &potentials) { + std::ofstream ostrm; + if (!filename.empty()) { + ostrm.open(filename); + if (!ostrm.good()) { + LOG(ERROR) << "WritePotentials: Can't open file: " << filename; + return false; + } + } + std::ostream &strm = ostrm.is_open() ? ostrm : std::cout; + strm.precision(9); + for (size_t s = 0; s < potentials.size(); ++s) { + strm << s << "\t" << potentials[s] << "\n"; + } + if (strm.fail()) { + LOG(ERROR) << "WritePotentials: Write failed: " + << (filename.empty() ? "standard output" : filename); + return false; + } + return true; +} + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/topsort.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/topsort.cc new file mode 100644 index 0000000000..8acd3d8ab4 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/topsort.cc @@ -0,0 +1,22 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +bool TopSort(MutableFstClass *fst) { + TopSortArgs args(fst); + Apply>("TopSort", fst->ArcType(), &args); + return args.retval; +} + +REGISTER_FST_OPERATION(TopSort, StdArc, TopSortArgs); +REGISTER_FST_OPERATION(TopSort, LogArc, TopSortArgs); +REGISTER_FST_OPERATION(TopSort, Log64Arc, TopSortArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/union.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/union.cc new file mode 100644 index 0000000000..c5e8720edf --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/union.cc @@ -0,0 +1,25 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +void Union(MutableFstClass *fst1, const FstClass &fst2) { + if (!internal::ArcTypesMatch(*fst1, fst2, "Union")) { + fst1->SetProperties(kError, kError); + return; + } + UnionArgs args(fst1, fst2); + Apply>("Union", fst1->ArcType(), &args); +} + +REGISTER_FST_OPERATION(Union, StdArc, UnionArgs); +REGISTER_FST_OPERATION(Union, LogArc, UnionArgs); +REGISTER_FST_OPERATION(Union, Log64Arc, UnionArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/verify.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/verify.cc new file mode 100644 index 0000000000..b6e74be31d --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/verify.cc @@ -0,0 +1,22 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include +#include +#include + +namespace fst { +namespace script { + +bool Verify(const FstClass &fst) { + VerifyArgs args(fst); + Apply>("Verify", fst.ArcType(), &args); + return args.retval; +} + +REGISTER_FST_OPERATION(Verify, StdArc, VerifyArgs); +REGISTER_FST_OPERATION(Verify, LogArc, VerifyArgs); +REGISTER_FST_OPERATION(Verify, Log64Arc, VerifyArgs); + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/weight-class.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/weight-class.cc new file mode 100644 index 0000000000..49db6bc398 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/script/weight-class.cc @@ -0,0 +1,102 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. + +#include + +namespace fst { +namespace script { + +REGISTER_FST_WEIGHT(StdArc::Weight); +REGISTER_FST_WEIGHT(LogArc::Weight); +REGISTER_FST_WEIGHT(Log64Arc::Weight); + +WeightClass::WeightClass(const string &weight_type, const string &weight_str) { + WeightClassRegister *reg = WeightClassRegister::GetRegister(); + StrToWeightImplBaseT stw = reg->GetEntry(weight_type); + if (!stw) { + FSTERROR() << "Unknown weight type: " << weight_type; + impl_.reset(); + return; + } + impl_.reset(stw(weight_str, "WeightClass", 0)); +} + +WeightClass WeightClass::Zero(const string &weight_type) { + return WeightClass(weight_type, __ZERO__); +} + +WeightClass WeightClass::One(const string &weight_type) { + return WeightClass(weight_type, __ONE__); +} + +WeightClass WeightClass::NoWeight(const string &weight_type) { + return WeightClass(weight_type, __NOWEIGHT__); +} + +bool WeightClass::WeightTypesMatch(const WeightClass &other, + const string &op_name) const { + if (Type() != other.Type()) { + FSTERROR() << "Weights with non-matching types passed to " << op_name + << ": " << Type() << " and " << other.Type(); + return false; + } + return true; +} + +bool operator==(const WeightClass &lhs, const WeightClass &rhs) { + const auto *lhs_impl = lhs.GetImpl(); + const auto *rhs_impl = rhs.GetImpl(); + if (!(lhs_impl && rhs_impl && lhs.WeightTypesMatch(rhs, "operator=="))) { + return false; + } + return *lhs_impl == *rhs_impl; +} + +bool operator!=(const WeightClass &lhs, const WeightClass &rhs) { + return !(lhs == rhs); +} + +WeightClass Plus(const WeightClass &lhs, const WeightClass &rhs) { + const auto *rhs_impl = rhs.GetImpl(); + if (!(lhs.GetImpl() && rhs_impl && lhs.WeightTypesMatch(rhs, "Plus"))) { + return WeightClass(); + } + WeightClass result(lhs); + result.GetImpl()->PlusEq(*rhs_impl); + return result; +} + +WeightClass Times(const WeightClass &lhs, const WeightClass &rhs) { + const auto *rhs_impl = rhs.GetImpl(); + if (!(lhs.GetImpl() && rhs_impl && lhs.WeightTypesMatch(rhs, "Plus"))) { + return WeightClass(); + } + WeightClass result(lhs); + result.GetImpl()->TimesEq(*rhs_impl); + return result; +} + +WeightClass Divide(const WeightClass &lhs, const WeightClass &rhs) { + const auto *rhs_impl = rhs.GetImpl(); + if (!(lhs.GetImpl() && rhs_impl && lhs.WeightTypesMatch(rhs, "Divide"))) { + return WeightClass(); + } + WeightClass result(lhs); + result.GetImpl()->DivideEq(*rhs_impl); + return result; +} + +WeightClass Power(const WeightClass &weight, size_t n) { + if (!weight.GetImpl()) return WeightClass(); + WeightClass result(weight); + result.GetImpl()->PowerEq(n); + return result; +} + +std::ostream &operator<<(std::ostream &ostrm, const WeightClass &weight) { + weight.impl_->Print(&ostrm); + return ostrm; +} + +} // namespace script +} // namespace fst diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/Makefile.am b/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/Makefile.am new file mode 100644 index 0000000000..768d07d08f --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/Makefile.am @@ -0,0 +1,32 @@ +AM_CPPFLAGS = -I$(srcdir)/../include $(ICU_CPPFLAGS) +LDADD = ../lib/libfst.la -lm $(DL_LIBS) + +check_PROGRAMS = fst_test weight_test + +fst_test_SOURCES = fst_test.cc fst_test.h + +weight_test_SOURCES = weight_test.cc weight-tester.h + +algo_test_SOURCES = algo_test.cc algo_test.h rand-fst.h + +check_PROGRAMS += algo_test_log +algo_test_log_SOURCES = $(algo_test_SOURCES) +algo_test_log_CPPFLAGS = -DTEST_LOG $(AM_CPPFLAGS) + +check_PROGRAMS += algo_test_tropical +algo_test_tropical_SOURCES = $(algo_test_SOURCES) +algo_test_tropical_CPPFLAGS = -DTEST_TROPICAL $(AM_CPPFLAGS) + +check_PROGRAMS += algo_test_minmax +algo_test_minmax_SOURCES = $(algo_test_SOURCES) +algo_test_minmax_CPPFLAGS = -DTEST_MINMAX $(AM_CPPFLAGS) + +check_PROGRAMS += algo_test_lexicographic +algo_test_lexicographic_SOURCES = $(algo_test_SOURCES) +algo_test_lexicographic_CPPFLAGS = -DTEST_LEXICOGRAPHIC $(AM_CPPFLAGS) + +check_PROGRAMS += algo_test_power +algo_test_power_SOURCES = $(algo_test_SOURCES) +algo_test_power_CPPFLAGS = -DTEST_POWER $(AM_CPPFLAGS) + +TESTS = $(check_PROGRAMS) diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/Makefile.in b/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/Makefile.in new file mode 100644 index 0000000000..670e907144 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/Makefile.in @@ -0,0 +1,1182 @@ +# Makefile.in generated by automake 1.14.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2013 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ +VPATH = @srcdir@ +am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +check_PROGRAMS = fst_test$(EXEEXT) weight_test$(EXEEXT) \ + algo_test_log$(EXEEXT) algo_test_tropical$(EXEEXT) \ + algo_test_minmax$(EXEEXT) algo_test_lexicographic$(EXEEXT) \ + algo_test_power$(EXEEXT) +subdir = src/test +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ + $(top_srcdir)/depcomp $(top_srcdir)/test-driver +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \ + $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ + $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ + $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h \ + $(top_builddir)/src/include/fst/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +am__objects_1 = algo_test_lexicographic-algo_test.$(OBJEXT) +am_algo_test_lexicographic_OBJECTS = $(am__objects_1) +algo_test_lexicographic_OBJECTS = \ + $(am_algo_test_lexicographic_OBJECTS) +algo_test_lexicographic_LDADD = $(LDADD) +am__DEPENDENCIES_1 = +algo_test_lexicographic_DEPENDENCIES = ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +AM_V_lt = $(am__v_lt_@AM_V@) +am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) +am__v_lt_0 = --silent +am__v_lt_1 = +am__objects_2 = algo_test_log-algo_test.$(OBJEXT) +am_algo_test_log_OBJECTS = $(am__objects_2) +algo_test_log_OBJECTS = $(am_algo_test_log_OBJECTS) +algo_test_log_LDADD = $(LDADD) +algo_test_log_DEPENDENCIES = ../lib/libfst.la $(am__DEPENDENCIES_1) +am__objects_3 = algo_test_minmax-algo_test.$(OBJEXT) +am_algo_test_minmax_OBJECTS = $(am__objects_3) +algo_test_minmax_OBJECTS = $(am_algo_test_minmax_OBJECTS) +algo_test_minmax_LDADD = $(LDADD) +algo_test_minmax_DEPENDENCIES = ../lib/libfst.la $(am__DEPENDENCIES_1) +am__objects_4 = algo_test_power-algo_test.$(OBJEXT) +am_algo_test_power_OBJECTS = $(am__objects_4) +algo_test_power_OBJECTS = $(am_algo_test_power_OBJECTS) +algo_test_power_LDADD = $(LDADD) +algo_test_power_DEPENDENCIES = ../lib/libfst.la $(am__DEPENDENCIES_1) +am__objects_5 = algo_test_tropical-algo_test.$(OBJEXT) +am_algo_test_tropical_OBJECTS = $(am__objects_5) +algo_test_tropical_OBJECTS = $(am_algo_test_tropical_OBJECTS) +algo_test_tropical_LDADD = $(LDADD) +algo_test_tropical_DEPENDENCIES = ../lib/libfst.la \ + $(am__DEPENDENCIES_1) +am_fst_test_OBJECTS = fst_test.$(OBJEXT) +fst_test_OBJECTS = $(am_fst_test_OBJECTS) +fst_test_LDADD = $(LDADD) +fst_test_DEPENDENCIES = ../lib/libfst.la $(am__DEPENDENCIES_1) +am_weight_test_OBJECTS = weight_test.$(OBJEXT) +weight_test_OBJECTS = $(am_weight_test_OBJECTS) +weight_test_LDADD = $(LDADD) +weight_test_DEPENDENCIES = ../lib/libfst.la $(am__DEPENDENCIES_1) +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +DEFAULT_INCLUDES = +depcomp = $(SHELL) $(top_srcdir)/depcomp +am__depfiles_maybe = depfiles +am__mv = mv -f +CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CXXFLAGS) $(CXXFLAGS) +AM_V_CXX = $(am__v_CXX_@AM_V@) +am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@) +am__v_CXX_0 = @echo " CXX " $@; +am__v_CXX_1 = +CXXLD = $(CXX) +CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_CXXLD = $(am__v_CXXLD_@AM_V@) +am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@) +am__v_CXXLD_0 = @echo " CXXLD " $@; +am__v_CXXLD_1 = +COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ + $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) +LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CFLAGS) $(CFLAGS) +AM_V_CC = $(am__v_CC_@AM_V@) +am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@) +am__v_CC_0 = @echo " CC " $@; +am__v_CC_1 = +CCLD = $(CC) +LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ + $(AM_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_CCLD = $(am__v_CCLD_@AM_V@) +am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@) +am__v_CCLD_0 = @echo " CCLD " $@; +am__v_CCLD_1 = +SOURCES = $(algo_test_lexicographic_SOURCES) $(algo_test_log_SOURCES) \ + $(algo_test_minmax_SOURCES) $(algo_test_power_SOURCES) \ + $(algo_test_tropical_SOURCES) $(fst_test_SOURCES) \ + $(weight_test_SOURCES) +DIST_SOURCES = $(algo_test_lexicographic_SOURCES) \ + $(algo_test_log_SOURCES) $(algo_test_minmax_SOURCES) \ + $(algo_test_power_SOURCES) $(algo_test_tropical_SOURCES) \ + $(fst_test_SOURCES) $(weight_test_SOURCES) +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +am__tty_colors_dummy = \ + mgn= red= grn= lgn= blu= brg= std=; \ + am__color_tests=no +am__tty_colors = { \ + $(am__tty_colors_dummy); \ + if test "X$(AM_COLOR_TESTS)" = Xno; then \ + am__color_tests=no; \ + elif test "X$(AM_COLOR_TESTS)" = Xalways; then \ + am__color_tests=yes; \ + elif test "X$$TERM" != Xdumb && { test -t 1; } 2>/dev/null; then \ + am__color_tests=yes; \ + fi; \ + if test $$am__color_tests = yes; then \ + red=''; \ + grn=''; \ + lgn=''; \ + blu=''; \ + mgn=''; \ + brg=''; \ + std=''; \ + fi; \ +} +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__uninstall_files_from_dir = { \ + test -z "$$files" \ + || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && rm -f $$files; }; \ + } +am__recheck_rx = ^[ ]*:recheck:[ ]* +am__global_test_result_rx = ^[ ]*:global-test-result:[ ]* +am__copy_in_global_log_rx = ^[ ]*:copy-in-global-log:[ ]* +# A command that, given a newline-separated list of test names on the +# standard input, print the name of the tests that are to be re-run +# upon "make recheck". +am__list_recheck_tests = $(AWK) '{ \ + recheck = 1; \ + while ((rc = (getline line < ($$0 ".trs"))) != 0) \ + { \ + if (rc < 0) \ + { \ + if ((getline line2 < ($$0 ".log")) < 0) \ + recheck = 0; \ + break; \ + } \ + else if (line ~ /$(am__recheck_rx)[nN][Oo]/) \ + { \ + recheck = 0; \ + break; \ + } \ + else if (line ~ /$(am__recheck_rx)[yY][eE][sS]/) \ + { \ + break; \ + } \ + }; \ + if (recheck) \ + print $$0; \ + close ($$0 ".trs"); \ + close ($$0 ".log"); \ +}' +# A command that, given a newline-separated list of test names on the +# standard input, create the global log from their .trs and .log files. +am__create_global_log = $(AWK) ' \ +function fatal(msg) \ +{ \ + print "fatal: making $@: " msg | "cat >&2"; \ + exit 1; \ +} \ +function rst_section(header) \ +{ \ + print header; \ + len = length(header); \ + for (i = 1; i <= len; i = i + 1) \ + printf "="; \ + printf "\n\n"; \ +} \ +{ \ + copy_in_global_log = 1; \ + global_test_result = "RUN"; \ + while ((rc = (getline line < ($$0 ".trs"))) != 0) \ + { \ + if (rc < 0) \ + fatal("failed to read from " $$0 ".trs"); \ + if (line ~ /$(am__global_test_result_rx)/) \ + { \ + sub("$(am__global_test_result_rx)", "", line); \ + sub("[ ]*$$", "", line); \ + global_test_result = line; \ + } \ + else if (line ~ /$(am__copy_in_global_log_rx)[nN][oO]/) \ + copy_in_global_log = 0; \ + }; \ + if (copy_in_global_log) \ + { \ + rst_section(global_test_result ": " $$0); \ + while ((rc = (getline line < ($$0 ".log"))) != 0) \ + { \ + if (rc < 0) \ + fatal("failed to read from " $$0 ".log"); \ + print line; \ + }; \ + printf "\n"; \ + }; \ + close ($$0 ".trs"); \ + close ($$0 ".log"); \ +}' +# Restructured Text title. +am__rst_title = { sed 's/.*/ & /;h;s/./=/g;p;x;s/ *$$//;p;g' && echo; } +# Solaris 10 'make', and several other traditional 'make' implementations, +# pass "-e" to $(SHELL), and POSIX 2008 even requires this. Work around it +# by disabling -e (using the XSI extension "set +e") if it's set. +am__sh_e_setup = case $$- in *e*) set +e;; esac +# Default flags passed to test drivers. +am__common_driver_flags = \ + --color-tests "$$am__color_tests" \ + --enable-hard-errors "$$am__enable_hard_errors" \ + --expect-failure "$$am__expect_failure" +# To be inserted before the command running the test. Creates the +# directory for the log if needed. Stores in $dir the directory +# containing $f, in $tst the test, in $log the log. Executes the +# developer- defined test setup AM_TESTS_ENVIRONMENT (if any), and +# passes TESTS_ENVIRONMENT. Set up options for the wrapper that +# will run the test scripts (or their associated LOG_COMPILER, if +# thy have one). +am__check_pre = \ +$(am__sh_e_setup); \ +$(am__vpath_adj_setup) $(am__vpath_adj) \ +$(am__tty_colors); \ +srcdir=$(srcdir); export srcdir; \ +case "$@" in \ + */*) am__odir=`echo "./$@" | sed 's|/[^/]*$$||'`;; \ + *) am__odir=.;; \ +esac; \ +test "x$$am__odir" = x"." || test -d "$$am__odir" \ + || $(MKDIR_P) "$$am__odir" || exit $$?; \ +if test -f "./$$f"; then dir=./; \ +elif test -f "$$f"; then dir=; \ +else dir="$(srcdir)/"; fi; \ +tst=$$dir$$f; log='$@'; \ +if test -n '$(DISABLE_HARD_ERRORS)'; then \ + am__enable_hard_errors=no; \ +else \ + am__enable_hard_errors=yes; \ +fi; \ +case " $(XFAIL_TESTS) " in \ + *[\ \ ]$$f[\ \ ]* | *[\ \ ]$$dir$$f[\ \ ]*) \ + am__expect_failure=yes;; \ + *) \ + am__expect_failure=no;; \ +esac; \ +$(AM_TESTS_ENVIRONMENT) $(TESTS_ENVIRONMENT) +# A shell command to get the names of the tests scripts with any registered +# extension removed (i.e., equivalently, the names of the test logs, with +# the '.log' extension removed). The result is saved in the shell variable +# '$bases'. This honors runtime overriding of TESTS and TEST_LOGS. Sadly, +# we cannot use something simpler, involving e.g., "$(TEST_LOGS:.log=)", +# since that might cause problem with VPATH rewrites for suffix-less tests. +# See also 'test-harness-vpath-rewrite.sh' and 'test-trs-basic.sh'. +am__set_TESTS_bases = \ + bases='$(TEST_LOGS)'; \ + bases=`for i in $$bases; do echo $$i; done | sed 's/\.log$$//'`; \ + bases=`echo $$bases` +RECHECK_LOGS = $(TEST_LOGS) +AM_RECURSIVE_TARGETS = check recheck +TEST_SUITE_LOG = test-suite.log +TEST_EXTENSIONS = @EXEEXT@ .test +LOG_DRIVER = $(SHELL) $(top_srcdir)/test-driver +LOG_COMPILE = $(LOG_COMPILER) $(AM_LOG_FLAGS) $(LOG_FLAGS) +am__set_b = \ + case '$@' in \ + */*) \ + case '$*' in \ + */*) b='$*';; \ + *) b=`echo '$@' | sed 's/\.log$$//'`; \ + esac;; \ + *) \ + b='$*';; \ + esac +am__test_logs1 = $(TESTS:=.log) +am__test_logs2 = $(am__test_logs1:@EXEEXT@.log=.log) +TEST_LOGS = $(am__test_logs2:.test.log=.log) +TEST_LOG_DRIVER = $(SHELL) $(top_srcdir)/test-driver +TEST_LOG_COMPILE = $(TEST_LOG_COMPILER) $(AM_TEST_LOG_FLAGS) \ + $(TEST_LOG_FLAGS) +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DL_LIBS = @DL_LIBS@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PYTHON = @PYTHON@ +PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@ +PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ +PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@ +PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@ +PYTHON_LDFLAGS = @PYTHON_LDFLAGS@ +PYTHON_PLATFORM = @PYTHON_PLATFORM@ +PYTHON_PREFIX = @PYTHON_PREFIX@ +PYTHON_SITE_PKG = @PYTHON_SITE_PKG@ +PYTHON_VERSION = @PYTHON_VERSION@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +libfstdir = @libfstdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgpyexecdir = @pkgpyexecdir@ +pkgpythondir = @pkgpythondir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +pyexecdir = @pyexecdir@ +pythondir = @pythondir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +AM_CPPFLAGS = -I$(srcdir)/../include $(ICU_CPPFLAGS) +LDADD = ../lib/libfst.la -lm $(DL_LIBS) +fst_test_SOURCES = fst_test.cc fst_test.h +weight_test_SOURCES = weight_test.cc weight-tester.h +algo_test_SOURCES = algo_test.cc algo_test.h rand-fst.h +algo_test_log_SOURCES = $(algo_test_SOURCES) +algo_test_log_CPPFLAGS = -DTEST_LOG $(AM_CPPFLAGS) +algo_test_tropical_SOURCES = $(algo_test_SOURCES) +algo_test_tropical_CPPFLAGS = -DTEST_TROPICAL $(AM_CPPFLAGS) +algo_test_minmax_SOURCES = $(algo_test_SOURCES) +algo_test_minmax_CPPFLAGS = -DTEST_MINMAX $(AM_CPPFLAGS) +algo_test_lexicographic_SOURCES = $(algo_test_SOURCES) +algo_test_lexicographic_CPPFLAGS = -DTEST_LEXICOGRAPHIC $(AM_CPPFLAGS) +algo_test_power_SOURCES = $(algo_test_SOURCES) +algo_test_power_CPPFLAGS = -DTEST_POWER $(AM_CPPFLAGS) +TESTS = $(check_PROGRAMS) +all: all-am + +.SUFFIXES: +.SUFFIXES: .cc .lo .log .o .obj .test .test$(EXEEXT) .trs +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/test/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign src/test/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +clean-checkPROGRAMS: + @list='$(check_PROGRAMS)'; test -n "$$list" || exit 0; \ + echo " rm -f" $$list; \ + rm -f $$list || exit $$?; \ + test -n "$(EXEEXT)" || exit 0; \ + list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \ + echo " rm -f" $$list; \ + rm -f $$list + +algo_test_lexicographic$(EXEEXT): $(algo_test_lexicographic_OBJECTS) $(algo_test_lexicographic_DEPENDENCIES) $(EXTRA_algo_test_lexicographic_DEPENDENCIES) + @rm -f algo_test_lexicographic$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(algo_test_lexicographic_OBJECTS) $(algo_test_lexicographic_LDADD) $(LIBS) + +algo_test_log$(EXEEXT): $(algo_test_log_OBJECTS) $(algo_test_log_DEPENDENCIES) $(EXTRA_algo_test_log_DEPENDENCIES) + @rm -f algo_test_log$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(algo_test_log_OBJECTS) $(algo_test_log_LDADD) $(LIBS) + +algo_test_minmax$(EXEEXT): $(algo_test_minmax_OBJECTS) $(algo_test_minmax_DEPENDENCIES) $(EXTRA_algo_test_minmax_DEPENDENCIES) + @rm -f algo_test_minmax$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(algo_test_minmax_OBJECTS) $(algo_test_minmax_LDADD) $(LIBS) + +algo_test_power$(EXEEXT): $(algo_test_power_OBJECTS) $(algo_test_power_DEPENDENCIES) $(EXTRA_algo_test_power_DEPENDENCIES) + @rm -f algo_test_power$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(algo_test_power_OBJECTS) $(algo_test_power_LDADD) $(LIBS) + +algo_test_tropical$(EXEEXT): $(algo_test_tropical_OBJECTS) $(algo_test_tropical_DEPENDENCIES) $(EXTRA_algo_test_tropical_DEPENDENCIES) + @rm -f algo_test_tropical$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(algo_test_tropical_OBJECTS) $(algo_test_tropical_LDADD) $(LIBS) + +fst_test$(EXEEXT): $(fst_test_OBJECTS) $(fst_test_DEPENDENCIES) $(EXTRA_fst_test_DEPENDENCIES) + @rm -f fst_test$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(fst_test_OBJECTS) $(fst_test_LDADD) $(LIBS) + +weight_test$(EXEEXT): $(weight_test_OBJECTS) $(weight_test_DEPENDENCIES) $(EXTRA_weight_test_DEPENDENCIES) + @rm -f weight_test$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(weight_test_OBJECTS) $(weight_test_LDADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/algo_test_lexicographic-algo_test.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/algo_test_log-algo_test.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/algo_test_minmax-algo_test.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/algo_test_power-algo_test.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/algo_test_tropical-algo_test.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fst_test.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/weight_test.Po@am__quote@ + +.cc.o: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $< + +.cc.obj: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cc.lo: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ +@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $< + +algo_test_lexicographic-algo_test.o: algo_test.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_lexicographic_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT algo_test_lexicographic-algo_test.o -MD -MP -MF $(DEPDIR)/algo_test_lexicographic-algo_test.Tpo -c -o algo_test_lexicographic-algo_test.o `test -f 'algo_test.cc' || echo '$(srcdir)/'`algo_test.cc +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/algo_test_lexicographic-algo_test.Tpo $(DEPDIR)/algo_test_lexicographic-algo_test.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='algo_test.cc' object='algo_test_lexicographic-algo_test.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_lexicographic_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o algo_test_lexicographic-algo_test.o `test -f 'algo_test.cc' || echo '$(srcdir)/'`algo_test.cc + +algo_test_lexicographic-algo_test.obj: algo_test.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_lexicographic_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT algo_test_lexicographic-algo_test.obj -MD -MP -MF $(DEPDIR)/algo_test_lexicographic-algo_test.Tpo -c -o algo_test_lexicographic-algo_test.obj `if test -f 'algo_test.cc'; then $(CYGPATH_W) 'algo_test.cc'; else $(CYGPATH_W) '$(srcdir)/algo_test.cc'; fi` +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/algo_test_lexicographic-algo_test.Tpo $(DEPDIR)/algo_test_lexicographic-algo_test.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='algo_test.cc' object='algo_test_lexicographic-algo_test.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_lexicographic_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o algo_test_lexicographic-algo_test.obj `if test -f 'algo_test.cc'; then $(CYGPATH_W) 'algo_test.cc'; else $(CYGPATH_W) '$(srcdir)/algo_test.cc'; fi` + +algo_test_log-algo_test.o: algo_test.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_log_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT algo_test_log-algo_test.o -MD -MP -MF $(DEPDIR)/algo_test_log-algo_test.Tpo -c -o algo_test_log-algo_test.o `test -f 'algo_test.cc' || echo '$(srcdir)/'`algo_test.cc +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/algo_test_log-algo_test.Tpo $(DEPDIR)/algo_test_log-algo_test.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='algo_test.cc' object='algo_test_log-algo_test.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_log_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o algo_test_log-algo_test.o `test -f 'algo_test.cc' || echo '$(srcdir)/'`algo_test.cc + +algo_test_log-algo_test.obj: algo_test.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_log_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT algo_test_log-algo_test.obj -MD -MP -MF $(DEPDIR)/algo_test_log-algo_test.Tpo -c -o algo_test_log-algo_test.obj `if test -f 'algo_test.cc'; then $(CYGPATH_W) 'algo_test.cc'; else $(CYGPATH_W) '$(srcdir)/algo_test.cc'; fi` +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/algo_test_log-algo_test.Tpo $(DEPDIR)/algo_test_log-algo_test.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='algo_test.cc' object='algo_test_log-algo_test.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_log_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o algo_test_log-algo_test.obj `if test -f 'algo_test.cc'; then $(CYGPATH_W) 'algo_test.cc'; else $(CYGPATH_W) '$(srcdir)/algo_test.cc'; fi` + +algo_test_minmax-algo_test.o: algo_test.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_minmax_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT algo_test_minmax-algo_test.o -MD -MP -MF $(DEPDIR)/algo_test_minmax-algo_test.Tpo -c -o algo_test_minmax-algo_test.o `test -f 'algo_test.cc' || echo '$(srcdir)/'`algo_test.cc +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/algo_test_minmax-algo_test.Tpo $(DEPDIR)/algo_test_minmax-algo_test.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='algo_test.cc' object='algo_test_minmax-algo_test.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_minmax_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o algo_test_minmax-algo_test.o `test -f 'algo_test.cc' || echo '$(srcdir)/'`algo_test.cc + +algo_test_minmax-algo_test.obj: algo_test.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_minmax_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT algo_test_minmax-algo_test.obj -MD -MP -MF $(DEPDIR)/algo_test_minmax-algo_test.Tpo -c -o algo_test_minmax-algo_test.obj `if test -f 'algo_test.cc'; then $(CYGPATH_W) 'algo_test.cc'; else $(CYGPATH_W) '$(srcdir)/algo_test.cc'; fi` +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/algo_test_minmax-algo_test.Tpo $(DEPDIR)/algo_test_minmax-algo_test.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='algo_test.cc' object='algo_test_minmax-algo_test.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_minmax_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o algo_test_minmax-algo_test.obj `if test -f 'algo_test.cc'; then $(CYGPATH_W) 'algo_test.cc'; else $(CYGPATH_W) '$(srcdir)/algo_test.cc'; fi` + +algo_test_power-algo_test.o: algo_test.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_power_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT algo_test_power-algo_test.o -MD -MP -MF $(DEPDIR)/algo_test_power-algo_test.Tpo -c -o algo_test_power-algo_test.o `test -f 'algo_test.cc' || echo '$(srcdir)/'`algo_test.cc +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/algo_test_power-algo_test.Tpo $(DEPDIR)/algo_test_power-algo_test.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='algo_test.cc' object='algo_test_power-algo_test.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_power_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o algo_test_power-algo_test.o `test -f 'algo_test.cc' || echo '$(srcdir)/'`algo_test.cc + +algo_test_power-algo_test.obj: algo_test.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_power_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT algo_test_power-algo_test.obj -MD -MP -MF $(DEPDIR)/algo_test_power-algo_test.Tpo -c -o algo_test_power-algo_test.obj `if test -f 'algo_test.cc'; then $(CYGPATH_W) 'algo_test.cc'; else $(CYGPATH_W) '$(srcdir)/algo_test.cc'; fi` +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/algo_test_power-algo_test.Tpo $(DEPDIR)/algo_test_power-algo_test.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='algo_test.cc' object='algo_test_power-algo_test.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_power_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o algo_test_power-algo_test.obj `if test -f 'algo_test.cc'; then $(CYGPATH_W) 'algo_test.cc'; else $(CYGPATH_W) '$(srcdir)/algo_test.cc'; fi` + +algo_test_tropical-algo_test.o: algo_test.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_tropical_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT algo_test_tropical-algo_test.o -MD -MP -MF $(DEPDIR)/algo_test_tropical-algo_test.Tpo -c -o algo_test_tropical-algo_test.o `test -f 'algo_test.cc' || echo '$(srcdir)/'`algo_test.cc +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/algo_test_tropical-algo_test.Tpo $(DEPDIR)/algo_test_tropical-algo_test.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='algo_test.cc' object='algo_test_tropical-algo_test.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_tropical_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o algo_test_tropical-algo_test.o `test -f 'algo_test.cc' || echo '$(srcdir)/'`algo_test.cc + +algo_test_tropical-algo_test.obj: algo_test.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_tropical_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT algo_test_tropical-algo_test.obj -MD -MP -MF $(DEPDIR)/algo_test_tropical-algo_test.Tpo -c -o algo_test_tropical-algo_test.obj `if test -f 'algo_test.cc'; then $(CYGPATH_W) 'algo_test.cc'; else $(CYGPATH_W) '$(srcdir)/algo_test.cc'; fi` +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/algo_test_tropical-algo_test.Tpo $(DEPDIR)/algo_test_tropical-algo_test.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='algo_test.cc' object='algo_test_tropical-algo_test.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_tropical_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o algo_test_tropical-algo_test.obj `if test -f 'algo_test.cc'; then $(CYGPATH_W) 'algo_test.cc'; else $(CYGPATH_W) '$(srcdir)/algo_test.cc'; fi` + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-am +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-am + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscopelist: cscopelist-am + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +# Recover from deleted '.trs' file; this should ensure that +# "rm -f foo.log; make foo.trs" re-run 'foo.test', and re-create +# both 'foo.log' and 'foo.trs'. Break the recipe in two subshells +# to avoid problems with "make -n". +.log.trs: + rm -f $< $@ + $(MAKE) $(AM_MAKEFLAGS) $< + +# Leading 'am--fnord' is there to ensure the list of targets does not +# expand to empty, as could happen e.g. with make check TESTS=''. +am--fnord $(TEST_LOGS) $(TEST_LOGS:.log=.trs): $(am__force_recheck) +am--force-recheck: + @: + +$(TEST_SUITE_LOG): $(TEST_LOGS) + @$(am__set_TESTS_bases); \ + am__f_ok () { test -f "$$1" && test -r "$$1"; }; \ + redo_bases=`for i in $$bases; do \ + am__f_ok $$i.trs && am__f_ok $$i.log || echo $$i; \ + done`; \ + if test -n "$$redo_bases"; then \ + redo_logs=`for i in $$redo_bases; do echo $$i.log; done`; \ + redo_results=`for i in $$redo_bases; do echo $$i.trs; done`; \ + if $(am__make_dryrun); then :; else \ + rm -f $$redo_logs && rm -f $$redo_results || exit 1; \ + fi; \ + fi; \ + if test -n "$$am__remaking_logs"; then \ + echo "fatal: making $(TEST_SUITE_LOG): possible infinite" \ + "recursion detected" >&2; \ + else \ + am__remaking_logs=yes $(MAKE) $(AM_MAKEFLAGS) $$redo_logs; \ + fi; \ + if $(am__make_dryrun); then :; else \ + st=0; \ + errmsg="fatal: making $(TEST_SUITE_LOG): failed to create"; \ + for i in $$redo_bases; do \ + test -f $$i.trs && test -r $$i.trs \ + || { echo "$$errmsg $$i.trs" >&2; st=1; }; \ + test -f $$i.log && test -r $$i.log \ + || { echo "$$errmsg $$i.log" >&2; st=1; }; \ + done; \ + test $$st -eq 0 || exit 1; \ + fi + @$(am__sh_e_setup); $(am__tty_colors); $(am__set_TESTS_bases); \ + ws='[ ]'; \ + results=`for b in $$bases; do echo $$b.trs; done`; \ + test -n "$$results" || results=/dev/null; \ + all=` grep "^$$ws*:test-result:" $$results | wc -l`; \ + pass=` grep "^$$ws*:test-result:$$ws*PASS" $$results | wc -l`; \ + fail=` grep "^$$ws*:test-result:$$ws*FAIL" $$results | wc -l`; \ + skip=` grep "^$$ws*:test-result:$$ws*SKIP" $$results | wc -l`; \ + xfail=`grep "^$$ws*:test-result:$$ws*XFAIL" $$results | wc -l`; \ + xpass=`grep "^$$ws*:test-result:$$ws*XPASS" $$results | wc -l`; \ + error=`grep "^$$ws*:test-result:$$ws*ERROR" $$results | wc -l`; \ + if test `expr $$fail + $$xpass + $$error` -eq 0; then \ + success=true; \ + else \ + success=false; \ + fi; \ + br='==================='; br=$$br$$br$$br$$br; \ + result_count () \ + { \ + if test x"$$1" = x"--maybe-color"; then \ + maybe_colorize=yes; \ + elif test x"$$1" = x"--no-color"; then \ + maybe_colorize=no; \ + else \ + echo "$@: invalid 'result_count' usage" >&2; exit 4; \ + fi; \ + shift; \ + desc=$$1 count=$$2; \ + if test $$maybe_colorize = yes && test $$count -gt 0; then \ + color_start=$$3 color_end=$$std; \ + else \ + color_start= color_end=; \ + fi; \ + echo "$${color_start}# $$desc $$count$${color_end}"; \ + }; \ + create_testsuite_report () \ + { \ + result_count $$1 "TOTAL:" $$all "$$brg"; \ + result_count $$1 "PASS: " $$pass "$$grn"; \ + result_count $$1 "SKIP: " $$skip "$$blu"; \ + result_count $$1 "XFAIL:" $$xfail "$$lgn"; \ + result_count $$1 "FAIL: " $$fail "$$red"; \ + result_count $$1 "XPASS:" $$xpass "$$red"; \ + result_count $$1 "ERROR:" $$error "$$mgn"; \ + }; \ + { \ + echo "$(PACKAGE_STRING): $(subdir)/$(TEST_SUITE_LOG)" | \ + $(am__rst_title); \ + create_testsuite_report --no-color; \ + echo; \ + echo ".. contents:: :depth: 2"; \ + echo; \ + for b in $$bases; do echo $$b; done \ + | $(am__create_global_log); \ + } >$(TEST_SUITE_LOG).tmp || exit 1; \ + mv $(TEST_SUITE_LOG).tmp $(TEST_SUITE_LOG); \ + if $$success; then \ + col="$$grn"; \ + else \ + col="$$red"; \ + test x"$$VERBOSE" = x || cat $(TEST_SUITE_LOG); \ + fi; \ + echo "$${col}$$br$${std}"; \ + echo "$${col}Testsuite summary for $(PACKAGE_STRING)$${std}"; \ + echo "$${col}$$br$${std}"; \ + create_testsuite_report --maybe-color; \ + echo "$$col$$br$$std"; \ + if $$success; then :; else \ + echo "$${col}See $(subdir)/$(TEST_SUITE_LOG)$${std}"; \ + if test -n "$(PACKAGE_BUGREPORT)"; then \ + echo "$${col}Please report to $(PACKAGE_BUGREPORT)$${std}"; \ + fi; \ + echo "$$col$$br$$std"; \ + fi; \ + $$success || exit 1 + +check-TESTS: + @list='$(RECHECK_LOGS)'; test -z "$$list" || rm -f $$list + @list='$(RECHECK_LOGS:.log=.trs)'; test -z "$$list" || rm -f $$list + @test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG) + @set +e; $(am__set_TESTS_bases); \ + log_list=`for i in $$bases; do echo $$i.log; done`; \ + trs_list=`for i in $$bases; do echo $$i.trs; done`; \ + log_list=`echo $$log_list`; trs_list=`echo $$trs_list`; \ + $(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) TEST_LOGS="$$log_list"; \ + exit $$?; +recheck: all $(check_PROGRAMS) + @test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG) + @set +e; $(am__set_TESTS_bases); \ + bases=`for i in $$bases; do echo $$i; done \ + | $(am__list_recheck_tests)` || exit 1; \ + log_list=`for i in $$bases; do echo $$i.log; done`; \ + log_list=`echo $$log_list`; \ + $(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) \ + am__force_recheck=am--force-recheck \ + TEST_LOGS="$$log_list"; \ + exit $$? +fst_test.log: fst_test$(EXEEXT) + @p='fst_test$(EXEEXT)'; \ + b='fst_test'; \ + $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) +weight_test.log: weight_test$(EXEEXT) + @p='weight_test$(EXEEXT)'; \ + b='weight_test'; \ + $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) +algo_test_log.log: algo_test_log$(EXEEXT) + @p='algo_test_log$(EXEEXT)'; \ + b='algo_test_log'; \ + $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) +algo_test_tropical.log: algo_test_tropical$(EXEEXT) + @p='algo_test_tropical$(EXEEXT)'; \ + b='algo_test_tropical'; \ + $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) +algo_test_minmax.log: algo_test_minmax$(EXEEXT) + @p='algo_test_minmax$(EXEEXT)'; \ + b='algo_test_minmax'; \ + $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) +algo_test_lexicographic.log: algo_test_lexicographic$(EXEEXT) + @p='algo_test_lexicographic$(EXEEXT)'; \ + b='algo_test_lexicographic'; \ + $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) +algo_test_power.log: algo_test_power$(EXEEXT) + @p='algo_test_power$(EXEEXT)'; \ + b='algo_test_power'; \ + $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) +.test.log: + @p='$<'; \ + $(am__set_b); \ + $(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) +@am__EXEEXT_TRUE@.test$(EXEEXT).log: +@am__EXEEXT_TRUE@ @p='$<'; \ +@am__EXEEXT_TRUE@ $(am__set_b); \ +@am__EXEEXT_TRUE@ $(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \ +@am__EXEEXT_TRUE@ --log-file $$b.log --trs-file $$b.trs \ +@am__EXEEXT_TRUE@ $(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \ +@am__EXEEXT_TRUE@ "$$tst" $(AM_TESTS_FD_REDIRECT) + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am + $(MAKE) $(AM_MAKEFLAGS) $(check_PROGRAMS) + $(MAKE) $(AM_MAKEFLAGS) check-TESTS +check: check-am +all-am: Makefile +installdirs: +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + -test -z "$(TEST_LOGS)" || rm -f $(TEST_LOGS) + -test -z "$(TEST_LOGS:.log=.trs)" || rm -f $(TEST_LOGS:.log=.trs) + -test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG) + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-checkPROGRAMS clean-generic clean-libtool \ + mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: + +.MAKE: check-am install-am install-strip + +.PHONY: CTAGS GTAGS TAGS all all-am check check-TESTS check-am clean \ + clean-checkPROGRAMS clean-generic clean-libtool cscopelist-am \ + ctags ctags-am distclean distclean-compile distclean-generic \ + distclean-libtool distclean-tags distdir dvi dvi-am html \ + html-am info info-am install install-am install-data \ + install-data-am install-dvi install-dvi-am install-exec \ + install-exec-am install-html install-html-am install-info \ + install-info-am install-man install-pdf install-pdf-am \ + install-ps install-ps-am install-strip installcheck \ + installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-compile \ + mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ + recheck tags tags-am uninstall uninstall-am + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/algo_test.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/algo_test.cc new file mode 100644 index 0000000000..0e947ebadc --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/algo_test.cc @@ -0,0 +1,128 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Regression test for various FST algorithms. + +#include "./algo_test.h" + +#include + +#include + +#include + +// DEFINEs determine which semirings are tested; these are controlled by +// the `defines` attributes of the associated build rules. + +DEFINE_int32(seed, -1, "random seed"); +DEFINE_int32(repeat, 25, "number of test repetitions"); + +using fst::AlgoTester; +using fst::ArcTpl; +using fst::GallicArc; +using fst::GallicWeight; +using fst::LexicographicArc; +using fst::LexicographicWeight; +using fst::LogArc; +using fst::LogWeight; +using fst::MinMaxArc; +using fst::MinMaxWeight; +using fst::PowerWeight; +using fst::STRING_LEFT; +using fst::STRING_RIGHT; +using fst::StdArc; +using fst::StringArc; +using fst::StringWeight; +using fst::TropicalWeight; +using fst::WeightGenerate; + +int main(int argc, char **argv) { + FLAGS_fst_verify_properties = true; + std::set_new_handler(FailedNewHandler); + SET_FLAGS(argv[0], &argc, &argv, true); + + static const int kCacheGcLimit = 20; + + srand(FLAGS_seed); + LOG(INFO) << "Seed = " << FLAGS_seed; + + FLAGS_fst_default_cache_gc = rand() % 2; + FLAGS_fst_default_cache_gc_limit = rand() % kCacheGcLimit; + VLOG(1) << "default_cache_gc:" << FLAGS_fst_default_cache_gc; + VLOG(1) << "default_cache_gc_limit:" << FLAGS_fst_default_cache_gc_limit; + +#ifdef TEST_TROPICAL + using TropicalWeightGenerate = WeightGenerate; + TropicalWeightGenerate tropical_generator(false); + AlgoTester tropical_tester( + tropical_generator, FLAGS_seed); + tropical_tester.Test(); +#endif // TEST_TROPICAL + +#ifdef TEST_LOG + using LogWeightGenerate = WeightGenerate; + LogWeightGenerate log_generator(false); + AlgoTester log_tester(log_generator, FLAGS_seed); + log_tester.Test(); +#endif // TEST_LOG + +#ifdef TEST_MINMAX + using MinMaxWeightGenerate = WeightGenerate; + MinMaxWeightGenerate minmax_generator(false); + AlgoTester minmax_tester(minmax_generator, + FLAGS_seed); + minmax_tester.Test(); +#endif + +#ifdef TEST_LEFT_STRING + using StringWeightGenerate = WeightGenerate>; + StringWeightGenerate left_string_generator(false); + AlgoTester, StringWeightGenerate> left_string_tester( + left_string_generator, FLAGS_seed); + left_string_tester.Test(); +#endif // TEST_LEFT_STRING + +#ifdef TEST_RIGHT_STRING + using StringWeightGenerate = + WeightGenerate>; + StringWeightGenerate right_string_generator(false); + AlgoTester, StringWeightGenerate> + right_string_tester(right_string_generator, FLAGS_seed); + right_string_tester.Test(); +#endif // TEST_RIGHT_STRING + +#ifdef TEST_GALLIC + using StdGallicArc = GallicArc; + using TropicalGallicWeightGenerate = + WeightGenerate>; + TropicalGallicWeightGenerate tropical_gallic_generator(false); + AlgoTester gallic_tester( + tropical_gallic_generator, FLAGS_seed); + gallic_tester.Test(); +#endif // TEST_GALLIC + +#ifdef TEST_LEXICOGRAPHIC + using TropicalLexicographicArc = + LexicographicArc; + using TropicalLexicographicWeightGenerate = + WeightGenerate>; + TropicalLexicographicWeightGenerate lexicographic_generator(false); + AlgoTester + lexicographic_tester(lexicographic_generator, FLAGS_seed); + lexicographic_tester.Test(); +#endif // TEST_LEXICOGRAPHIC + +#ifdef TEST_POWER + using TropicalCubeWeight = PowerWeight; + using TropicalCubeArc = ArcTpl; + using TropicalCubeWeightGenerate = WeightGenerate; + TropicalCubeWeightGenerate tropical_cube_generator(false); + AlgoTester tropical_cube_tester( + tropical_cube_generator, FLAGS_seed); + tropical_cube_tester.Test(); +#endif // TEST_POWER + + std::cout << "PASS" << std::endl; + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/algo_test.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/algo_test.h new file mode 100644 index 0000000000..f9dcd1a241 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/algo_test.h @@ -0,0 +1,1411 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Regression test for various FST algorithms. + +#ifndef FST_TEST_ALGO_TEST_H_ +#define FST_TEST_ALGO_TEST_H_ + +#include + +#include +#include "./rand-fst.h" + +DECLARE_int32(repeat); // defined in ./algo_test.cc + +namespace fst { + +// Mapper to change input and output label of every transition into +// epsilons. +template +class EpsMapper { + public: + EpsMapper() {} + + A operator()(const A &arc) const { + return A(0, 0, arc.weight, arc.nextstate); + } + + uint64 Properties(uint64 props) const { + props &= ~kNotAcceptor; + props |= kAcceptor; + props &= ~kNoIEpsilons & ~kNoOEpsilons & ~kNoEpsilons; + props |= kIEpsilons | kOEpsilons | kEpsilons; + props &= ~kNotILabelSorted & ~kNotOLabelSorted; + props |= kILabelSorted | kOLabelSorted; + return props; + } + + MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; } + + MapSymbolsAction InputSymbolsAction() const { return MAP_COPY_SYMBOLS; } + + MapSymbolsAction OutputSymbolsAction() const { return MAP_COPY_SYMBOLS; } +}; + +// Generic - no lookahead. +template +void LookAheadCompose(const Fst &ifst1, const Fst &ifst2, + MutableFst *ofst) { + Compose(ifst1, ifst2, ofst); +} + +// Specialized and epsilon olabel acyclic - lookahead. +void LookAheadCompose(const Fst &ifst1, const Fst &ifst2, + MutableFst *ofst) { + std::vector order; + bool acyclic; + TopOrderVisitor visitor(&order, &acyclic); + DfsVisit(ifst1, &visitor, OutputEpsilonArcFilter()); + if (acyclic) { // no ifst1 output epsilon cycles? + StdOLabelLookAheadFst lfst1(ifst1); + StdVectorFst lfst2(ifst2); + LabelLookAheadRelabeler::Relabel(&lfst2, lfst1, true); + Compose(lfst1, lfst2, ofst); + } else { + Compose(ifst1, ifst2, ofst); + } +} + +// This class tests a variety of identities and properties that must +// hold for various algorithms on weighted FSTs. +template +class WeightedTester { + public: + typedef typename Arc::Label Label; + typedef typename Arc::StateId StateId; + typedef typename Arc::Weight Weight; + + WeightedTester(time_t seed, const Fst &zero_fst, const Fst &one_fst, + const Fst &univ_fst, WeightGenerator *weight_generator) + : seed_(seed), + zero_fst_(zero_fst), + one_fst_(one_fst), + univ_fst_(univ_fst), + weight_generator_(weight_generator) {} + + void Test(const Fst &T1, const Fst &T2, const Fst &T3) { + TestRational(T1, T2, T3); + TestMap(T1); + TestCompose(T1, T2, T3); + TestSort(T1); + TestOptimize(T1); + TestSearch(T1); + } + + private: + // Tests rational operations with identities + void TestRational(const Fst &T1, const Fst &T2, + const Fst &T3) { + { + VLOG(1) << "Check destructive and delayed union are equivalent."; + VectorFst U1(T1); + Union(&U1, T2); + UnionFst U2(T1, T2); + CHECK(Equiv(U1, U2)); + } + + { + VLOG(1) << "Check destructive and delayed concatenation are equivalent."; + VectorFst C1(T1); + Concat(&C1, T2); + ConcatFst C2(T1, T2); + CHECK(Equiv(C1, C2)); + VectorFst C3(T2); + Concat(T1, &C3); + CHECK(Equiv(C3, C2)); + } + + { + VLOG(1) << "Check destructive and delayed closure* are equivalent."; + VectorFst C1(T1); + Closure(&C1, CLOSURE_STAR); + ClosureFst C2(T1, CLOSURE_STAR); + CHECK(Equiv(C1, C2)); + } + + { + VLOG(1) << "Check destructive and delayed closure+ are equivalent."; + VectorFst C1(T1); + Closure(&C1, CLOSURE_PLUS); + ClosureFst C2(T1, CLOSURE_PLUS); + CHECK(Equiv(C1, C2)); + } + + { + VLOG(1) << "Check union is associative (destructive)."; + VectorFst U1(T1); + Union(&U1, T2); + Union(&U1, T3); + + VectorFst U3(T2); + Union(&U3, T3); + VectorFst U4(T1); + Union(&U4, U3); + + CHECK(Equiv(U1, U4)); + } + + { + VLOG(1) << "Check union is associative (delayed)."; + UnionFst U1(T1, T2); + UnionFst U2(U1, T3); + + UnionFst U3(T2, T3); + UnionFst U4(T1, U3); + + CHECK(Equiv(U2, U4)); + } + + { + VLOG(1) << "Check union is associative (destructive delayed)."; + UnionFst U1(T1, T2); + Union(&U1, T3); + + UnionFst U3(T2, T3); + UnionFst U4(T1, U3); + + CHECK(Equiv(U1, U4)); + } + + { + VLOG(1) << "Check concatenation is associative (destructive)."; + VectorFst C1(T1); + Concat(&C1, T2); + Concat(&C1, T3); + + VectorFst C3(T2); + Concat(&C3, T3); + VectorFst C4(T1); + Concat(&C4, C3); + + CHECK(Equiv(C1, C4)); + } + + { + VLOG(1) << "Check concatenation is associative (delayed)."; + ConcatFst C1(T1, T2); + ConcatFst C2(C1, T3); + + ConcatFst C3(T2, T3); + ConcatFst C4(T1, C3); + + CHECK(Equiv(C2, C4)); + } + + { + VLOG(1) << "Check concatenation is associative (destructive delayed)."; + ConcatFst C1(T1, T2); + Concat(&C1, T3); + + ConcatFst C3(T2, T3); + ConcatFst C4(T1, C3); + + CHECK(Equiv(C1, C4)); + } + + if (Weight::Properties() & kLeftSemiring) { + VLOG(1) << "Check concatenation left distributes" + << " over union (destructive)."; + + VectorFst U1(T1); + Union(&U1, T2); + VectorFst C1(T3); + Concat(&C1, U1); + + VectorFst C2(T3); + Concat(&C2, T1); + VectorFst C3(T3); + Concat(&C3, T2); + VectorFst U2(C2); + Union(&U2, C3); + + CHECK(Equiv(C1, U2)); + } + + if (Weight::Properties() & kRightSemiring) { + VLOG(1) << "Check concatenation right distributes" + << " over union (destructive)."; + VectorFst U1(T1); + Union(&U1, T2); + VectorFst C1(U1); + Concat(&C1, T3); + + VectorFst C2(T1); + Concat(&C2, T3); + VectorFst C3(T2); + Concat(&C3, T3); + VectorFst U2(C2); + Union(&U2, C3); + + CHECK(Equiv(C1, U2)); + } + + if (Weight::Properties() & kLeftSemiring) { + VLOG(1) << "Check concatenation left distributes over union (delayed)."; + UnionFst U1(T1, T2); + ConcatFst C1(T3, U1); + + ConcatFst C2(T3, T1); + ConcatFst C3(T3, T2); + UnionFst U2(C2, C3); + + CHECK(Equiv(C1, U2)); + } + + if (Weight::Properties() & kRightSemiring) { + VLOG(1) << "Check concatenation right distributes over union (delayed)."; + UnionFst U1(T1, T2); + ConcatFst C1(U1, T3); + + ConcatFst C2(T1, T3); + ConcatFst C3(T2, T3); + UnionFst U2(C2, C3); + + CHECK(Equiv(C1, U2)); + } + + if (Weight::Properties() & kLeftSemiring) { + VLOG(1) << "Check T T* == T+ (destructive)."; + VectorFst S(T1); + Closure(&S, CLOSURE_STAR); + VectorFst C(T1); + Concat(&C, S); + + VectorFst P(T1); + Closure(&P, CLOSURE_PLUS); + + CHECK(Equiv(C, P)); + } + + if (Weight::Properties() & kRightSemiring) { + VLOG(1) << "Check T* T == T+ (destructive)."; + VectorFst S(T1); + Closure(&S, CLOSURE_STAR); + VectorFst C(S); + Concat(&C, T1); + + VectorFst P(T1); + Closure(&P, CLOSURE_PLUS); + + CHECK(Equiv(C, P)); + } + + if (Weight::Properties() & kLeftSemiring) { + VLOG(1) << "Check T T* == T+ (delayed)."; + ClosureFst S(T1, CLOSURE_STAR); + ConcatFst C(T1, S); + + ClosureFst P(T1, CLOSURE_PLUS); + + CHECK(Equiv(C, P)); + } + + if (Weight::Properties() & kRightSemiring) { + VLOG(1) << "Check T* T == T+ (delayed)."; + ClosureFst S(T1, CLOSURE_STAR); + ConcatFst C(S, T1); + + ClosureFst P(T1, CLOSURE_PLUS); + + CHECK(Equiv(C, P)); + } + } + + // Tests map-based operations. + void TestMap(const Fst &T) { + { + VLOG(1) << "Check destructive and delayed projection are equivalent."; + VectorFst P1(T); + Project(&P1, PROJECT_INPUT); + ProjectFst P2(T, PROJECT_INPUT); + CHECK(Equiv(P1, P2)); + } + + { + VLOG(1) << "Check destructive and delayed inversion are equivalent."; + VectorFst I1(T); + Invert(&I1); + InvertFst I2(T); + CHECK(Equiv(I1, I2)); + } + + { + VLOG(1) << "Check Pi_1(T) = Pi_2(T^-1) (destructive)."; + VectorFst P1(T); + VectorFst I1(T); + Project(&P1, PROJECT_INPUT); + Invert(&I1); + Project(&I1, PROJECT_OUTPUT); + CHECK(Equiv(P1, I1)); + } + + { + VLOG(1) << "Check Pi_2(T) = Pi_1(T^-1) (destructive)."; + VectorFst P1(T); + VectorFst I1(T); + Project(&P1, PROJECT_OUTPUT); + Invert(&I1); + Project(&I1, PROJECT_INPUT); + CHECK(Equiv(P1, I1)); + } + + { + VLOG(1) << "Check Pi_1(T) = Pi_2(T^-1) (delayed)."; + ProjectFst P1(T, PROJECT_INPUT); + InvertFst I1(T); + ProjectFst P2(I1, PROJECT_OUTPUT); + CHECK(Equiv(P1, P2)); + } + + { + VLOG(1) << "Check Pi_2(T) = Pi_1(T^-1) (delayed)."; + ProjectFst P1(T, PROJECT_OUTPUT); + InvertFst I1(T); + ProjectFst P2(I1, PROJECT_INPUT); + CHECK(Equiv(P1, P2)); + } + + { + VLOG(1) << "Check destructive relabeling"; + static const int kNumLabels = 10; + // set up relabeling pairs + std::vector &fst1, const Fst &fst2) { + VLOG(1) << "Check FSTs for sanity (including property bits)."; + CHECK(Verify(fst1)); + CHECK(Verify(fst2)); + + // Ensures seed used once per instantiation. + static UniformArcSelector uniform_selector(seed_); + RandGenOptions> opts(uniform_selector, + kRandomPathLength); + return RandEquivalent(fst1, fst2, kNumRandomPaths, kTestDelta, opts); + } + + // Tests FSA is unambiguous + bool Unambiguous(const Fst &fst) { + VectorFst sfst, dfst; + VectorFst lfst1, lfst2; + Map(fst, &sfst, RmWeightMapper()); + Determinize(sfst, &dfst); + Map(fst, &lfst1, RmWeightMapper()); + Map(dfst, &lfst2, RmWeightMapper()); + return Equiv(lfst1, lfst2); + } + + // Ensures input-epsilon free transducers fst1 and fst2 have the + // same domain and that for each string pair '(is, os)' in fst1, + // '(is, os)' is the minimum weight match to 'is' in fst2. + template + bool MinRelated(const Fst &fst1, const Fst &fst2) { + // Same domain + VectorFst P1(fst1), P2(fst2); + Project(&P1, PROJECT_INPUT); + Project(&P2, PROJECT_INPUT); + if (!Equiv(P1, P2)) { + LOG(ERROR) << "Inputs not equivalent"; + return false; + } + + // Ensures seed used once per instantiation. + static UniformArcSelector uniform_selector(seed_); + RandGenOptions> opts(uniform_selector, + kRandomPathLength); + + VectorFst path, paths1, paths2; + for (ssize_t n = 0; n < kNumRandomPaths; ++n) { + RandGen(fst1, &path, opts); + Invert(&path); + Map(&path, RmWeightMapper()); + Compose(path, fst2, &paths1); + Weight sum1 = ShortestDistance(paths1); + Compose(paths1, path, &paths2); + Weight sum2 = ShortestDistance(paths2); + if (!ApproxEqual(Plus(sum1, sum2), sum2, kTestDelta)) { + LOG(ERROR) << "Sums not equivalent: " << sum1 << " " << sum2; + return false; + } + } + return true; + } + + // Tests ShortestDistance(A - P) >= + // ShortestDistance(A) times Threshold. + template + bool PruneEquiv(const Fst &fst, const Fst &pfst, Weight threshold) { + VLOG(1) << "Check FSTs for sanity (including property bits)."; + CHECK(Verify(fst)); + CHECK(Verify(pfst)); + + DifferenceFst D(fst, DeterminizeFst(RmEpsilonFst( + ArcMapFst>( + pfst, RmWeightMapper())))); + Weight sum1 = Times(ShortestDistance(fst), threshold); + Weight sum2 = ShortestDistance(D); + return ApproxEqual(Plus(sum1, sum2), sum1, kTestDelta); + } + + // Random seed. + int seed_; + // FST with no states + VectorFst zero_fst_; + // FST with one state that accepts epsilon. + VectorFst one_fst_; + // FST with one state that accepts all strings. + VectorFst univ_fst_; + // Generates weights used in testing. + WeightGenerator *weight_generator_; + // Maximum random path length. + static const int kRandomPathLength; + // Number of random paths to explore. + static const int kNumRandomPaths; + // Maximum number of nshortest paths. + static const int kNumRandomShortestPaths; + // Maximum number of nshortest states. + static const int kNumShortestStates; + // Delta for equivalence tests. + static const float kTestDelta; + + WeightedTester(const WeightedTester &) = delete; + WeightedTester &operator=(const WeightedTester &) = delete; +}; + +template +const int WeightedTester::kRandomPathLength = 25; + +template +const int WeightedTester::kNumRandomPaths = 100; + +template +const int WeightedTester::kNumRandomShortestPaths = 100; + +template +const int WeightedTester::kNumShortestStates = 10000; + +template +const float WeightedTester::kTestDelta = .05; + +// This class tests a variety of identities and properties that must +// hold for various algorithms on unweighted FSAs and that are not tested +// by WeightedTester. Only the specialization does anything interesting. +template +class UnweightedTester { + public: + UnweightedTester(const Fst &zero_fsa, const Fst &one_fsa, + const Fst &univ_fsa) {} + + void Test(const Fst &A1, const Fst &A2, const Fst &A3) {} +}; + +// Specialization for StdArc. This should work for any commutative, +// idempotent semiring when restricted to the unweighted case +// (being isomorphic to the boolean semiring). +template <> +class UnweightedTester { + public: + typedef StdArc Arc; + typedef Arc::Label Label; + typedef Arc::StateId StateId; + typedef Arc::Weight Weight; + + UnweightedTester(const Fst &zero_fsa, const Fst &one_fsa, + const Fst &univ_fsa) + : zero_fsa_(zero_fsa), one_fsa_(one_fsa), univ_fsa_(univ_fsa) {} + + void Test(const Fst &A1, const Fst &A2, const Fst &A3) { + TestRational(A1, A2, A3); + TestIntersect(A1, A2, A3); + TestOptimize(A1); + } + + private: + // Tests rational operations with identities + void TestRational(const Fst &A1, const Fst &A2, + const Fst &A3) { + { + VLOG(1) << "Check the union contains its arguments (destructive)."; + VectorFst U(A1); + Union(&U, A2); + + CHECK(Subset(A1, U)); + CHECK(Subset(A2, U)); + } + + { + VLOG(1) << "Check the union contains its arguments (delayed)."; + UnionFst U(A1, A2); + + CHECK(Subset(A1, U)); + CHECK(Subset(A2, U)); + } + + { + VLOG(1) << "Check if A^n c A* (destructive)."; + VectorFst C(one_fsa_); + int n = rand() % 5; + for (int i = 0; i < n; ++i) Concat(&C, A1); + + VectorFst S(A1); + Closure(&S, CLOSURE_STAR); + CHECK(Subset(C, S)); + } + + { + VLOG(1) << "Check if A^n c A* (delayed)."; + int n = rand() % 5; + Fst *C = new VectorFst(one_fsa_); + for (int i = 0; i < n; ++i) { + ConcatFst *F = new ConcatFst(*C, A1); + delete C; + C = F; + } + ClosureFst S(A1, CLOSURE_STAR); + CHECK(Subset(*C, S)); + delete C; + } + } + + // Tests intersect-based operations. + void TestIntersect(const Fst &A1, const Fst &A2, + const Fst &A3) { + VectorFst S1(A1); + VectorFst S2(A2); + VectorFst S3(A3); + + ILabelCompare comp; + + ArcSort(&S1, comp); + ArcSort(&S2, comp); + ArcSort(&S3, comp); + + { + VLOG(1) << "Check the intersection is contained in its arguments."; + IntersectFst I1(S1, S2); + CHECK(Subset(I1, S1)); + CHECK(Subset(I1, S2)); + } + + { + VLOG(1) << "Check union distributes over intersection."; + IntersectFst I1(S1, S2); + UnionFst U1(I1, S3); + + UnionFst U2(S1, S3); + UnionFst U3(S2, S3); + ArcSortFst> S4(U3, comp); + IntersectFst I2(U2, S4); + + CHECK(Equiv(U1, I2)); + } + + VectorFst C1; + VectorFst C2; + Complement(S1, &C1); + Complement(S2, &C2); + ArcSort(&C1, comp); + ArcSort(&C2, comp); + + { + VLOG(1) << "Check S U S' = Sigma*"; + UnionFst U(S1, C1); + CHECK(Equiv(U, univ_fsa_)); + } + + { + VLOG(1) << "Check S n S' = {}"; + IntersectFst I(S1, C1); + CHECK(Equiv(I, zero_fsa_)); + } + + { + VLOG(1) << "Check (S1' U S2') == (S1 n S2)'"; + UnionFst U(C1, C2); + + IntersectFst I(S1, S2); + VectorFst C3; + Complement(I, &C3); + CHECK(Equiv(U, C3)); + } + + { + VLOG(1) << "Check (S1' n S2') == (S1 U S2)'"; + IntersectFst I(C1, C2); + + UnionFst U(S1, S2); + VectorFst C3; + Complement(U, &C3); + CHECK(Equiv(I, C3)); + } + } + + // Tests optimization operations + void TestOptimize(const Fst &A) { + { + VLOG(1) << "Check determinized FSA is equivalent to its input."; + DeterminizeFst D(A); + CHECK(Equiv(A, D)); + } + + { + VLOG(1) << "Check disambiguated FSA is equivalent to its input."; + VectorFst R(A), D; + RmEpsilon(&R); + + Disambiguate(R, &D); + CHECK(Equiv(R, D)); + } + + { + VLOG(1) << "Check minimized FSA is equivalent to its input."; + int n; + { + RmEpsilonFst R(A); + DeterminizeFst D(R); + VectorFst M(D); + Minimize(&M, static_cast *>(nullptr), kDelta); + CHECK(Equiv(A, M)); + n = M.NumStates(); + } + + if (n) { // Skip test if A is the empty machine + VLOG(1) << "Check that Hopcroft's and Revuz's algorithms lead to the" + << " same number of states as Brozozowski's algorithm"; + VectorFst R; + Reverse(A, &R); + RmEpsilon(&R); + DeterminizeFst DR(R); + VectorFst RD; + Reverse(DR, &RD); + DeterminizeFst DRD(RD); + VectorFst M(DRD); + CHECK_EQ(n + 1, M.NumStates()); // Accounts for the epsilon transition + // to the initial state + } + } + } + + // Tests if two FSAS are equivalent. + bool Equiv(const Fst &fsa1, const Fst &fsa2) { + VLOG(1) << "Check FSAs for sanity (including property bits)."; + CHECK(Verify(fsa1)); + CHECK(Verify(fsa2)); + + VectorFst vfsa1(fsa1); + VectorFst vfsa2(fsa2); + RmEpsilon(&vfsa1); + RmEpsilon(&vfsa2); + DeterminizeFst dfa1(vfsa1); + DeterminizeFst dfa2(vfsa2); + + // Test equivalence using union-find algorithm + bool equiv1 = Equivalent(dfa1, dfa2); + + // Test equivalence by checking if (S1 - S2) U (S2 - S1) is empty + ILabelCompare comp; + VectorFst sdfa1(dfa1); + ArcSort(&sdfa1, comp); + VectorFst sdfa2(dfa2); + ArcSort(&sdfa2, comp); + + DifferenceFst dfsa1(sdfa1, sdfa2); + DifferenceFst dfsa2(sdfa2, sdfa1); + + VectorFst ufsa(dfsa1); + Union(&ufsa, dfsa2); + Connect(&ufsa); + bool equiv2 = ufsa.NumStates() == 0; + + // Check two equivalence tests match + CHECK((equiv1 && equiv2) || (!equiv1 && !equiv2)); + + return equiv1; + } + + // Tests if FSA1 is a subset of FSA2 (disregarding weights). + bool Subset(const Fst &fsa1, const Fst &fsa2) { + VLOG(1) << "Check FSAs (incl. property bits) for sanity"; + CHECK(Verify(fsa1)); + CHECK(Verify(fsa2)); + + VectorFst vfsa1; + VectorFst vfsa2; + RmEpsilon(&vfsa1); + RmEpsilon(&vfsa2); + ILabelCompare comp; + ArcSort(&vfsa1, comp); + ArcSort(&vfsa2, comp); + IntersectFst ifsa(vfsa1, vfsa2); + DeterminizeFst dfa1(vfsa1); + DeterminizeFst dfa2(ifsa); + return Equivalent(dfa1, dfa2); + } + + // Returns complement Fsa + void Complement(const Fst &ifsa, MutableFst *ofsa) { + RmEpsilonFst rfsa(ifsa); + DeterminizeFst dfa(rfsa); + DifferenceFst cfsa(univ_fsa_, dfa); + *ofsa = cfsa; + } + + // FSA with no states + VectorFst zero_fsa_; + + // FSA with one state that accepts epsilon. + VectorFst one_fsa_; + + // FSA with one state that accepts all strings. + VectorFst univ_fsa_; +}; + +// This class tests a variety of identities and properties that must +// hold for various FST algorithms. It randomly generates FSTs, using +// function object 'weight_generator' to select weights. 'WeightTester' +// and 'UnweightedTester' are then called. +template +class AlgoTester { + public: + typedef typename Arc::Label Label; + typedef typename Arc::StateId StateId; + typedef typename Arc::Weight Weight; + + AlgoTester(WeightGenerator generator, int seed) + : weight_generator_(generator) { + one_fst_.AddState(); + one_fst_.SetStart(0); + one_fst_.SetFinal(0, Weight::One()); + + univ_fst_.AddState(); + univ_fst_.SetStart(0); + univ_fst_.SetFinal(0, Weight::One()); + for (int i = 0; i < kNumRandomLabels; ++i) + univ_fst_.AddArc(0, Arc(i, i, Weight::One(), 0)); + + weighted_tester_ = new WeightedTester( + seed, zero_fst_, one_fst_, univ_fst_, &weight_generator_); + + unweighted_tester_ = + new UnweightedTester(zero_fst_, one_fst_, univ_fst_); + } + + ~AlgoTester() { + delete weighted_tester_; + delete unweighted_tester_; + } + + void MakeRandFst(MutableFst *fst) { + RandFst(kNumRandomStates, kNumRandomArcs, + kNumRandomLabels, kAcyclicProb, + &weight_generator_, fst); + } + + void Test() { + VLOG(1) << "weight type = " << Weight::Type(); + + for (int i = 0; i < FLAGS_repeat; ++i) { + // Random transducers + VectorFst T1; + VectorFst T2; + VectorFst T3; + MakeRandFst(&T1); + MakeRandFst(&T2); + MakeRandFst(&T3); + weighted_tester_->Test(T1, T2, T3); + + VectorFst A1(T1); + VectorFst A2(T2); + VectorFst A3(T3); + Project(&A1, PROJECT_OUTPUT); + Project(&A2, PROJECT_INPUT); + Project(&A3, PROJECT_INPUT); + ArcMap(&A1, rm_weight_mapper_); + ArcMap(&A2, rm_weight_mapper_); + ArcMap(&A3, rm_weight_mapper_); + unweighted_tester_->Test(A1, A2, A3); + } + } + + private: + // Generates weights used in testing. + WeightGenerator weight_generator_; + + // FST with no states + VectorFst zero_fst_; + + // FST with one state that accepts epsilon. + VectorFst one_fst_; + + // FST with one state that accepts all strings. + VectorFst univ_fst_; + + // Tests weighted FSTs + WeightedTester *weighted_tester_; + + // Tests unweighted FSTs + UnweightedTester *unweighted_tester_; + + // Mapper to remove weights from an Fst + RmWeightMapper rm_weight_mapper_; + + // Maximum number of states in random test Fst. + static const int kNumRandomStates; + + // Maximum number of arcs in random test Fst. + static const int kNumRandomArcs; + + // Number of alternative random labels. + static const int kNumRandomLabels; + + // Probability to force an acyclic Fst + static const float kAcyclicProb; + + // Maximum random path length. + static const int kRandomPathLength; + + // Number of random paths to explore. + static const int kNumRandomPaths; + + AlgoTester(const AlgoTester &) = delete; + AlgoTester &operator=(const AlgoTester &) = delete; +}; + +template +const int AlgoTester::kNumRandomStates = 10; + +template +const int AlgoTester::kNumRandomArcs = 25; + +template +const int AlgoTester::kNumRandomLabels = 5; + +template +const float AlgoTester::kAcyclicProb = .25; + +template +const int AlgoTester::kRandomPathLength = 25; + +template +const int AlgoTester::kNumRandomPaths = 100; + +} // namespace fst + +#endif // FST_TEST_ALGO_TEST_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/fst_test.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/fst_test.cc new file mode 100644 index 0000000000..f6d6b03fb7 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/fst_test.cc @@ -0,0 +1,209 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Regression test for FST classes. + +#include "./fst_test.h" + +#include + +#include +#include +#include +#include +#include +#include + +namespace fst { +namespace { + +// A user-defined arc type. +struct CustomArc { + typedef int16 Label; + typedef ProductWeight Weight; + typedef int64 StateId; + + CustomArc(Label i, Label o, Weight w, StateId s) + : ilabel(i), olabel(o), weight(std::move(w)), nextstate(s) {} + CustomArc() {} + + static const string &Type() { // Arc type name + static const string *const type = new string("my"); + return *type; + } + + Label ilabel; // Transition input label + Label olabel; // Transition output label + Weight weight; // Transition weight + StateId nextstate; // Transition destination state +}; + +// A user-defined compactor for test FST. +template +class CustomCompactor { + public: + typedef A Arc; + typedef typename A::Label Label; + typedef typename A::StateId StateId; + typedef typename A::Weight Weight; + typedef std::pair Element; + + Element Compact(StateId s, const A &arc) const { + return std::make_pair(arc.ilabel, arc.weight); + } + + Arc Expand(StateId s, const Element &p, uint32 f = kArcValueFlags) const { + return p.first == kNoLabel ? Arc(kNoLabel, kNoLabel, p.second, kNoStateId) + : Arc(p.first, 0, p.second, s); + } + + ssize_t Size() const { return -1; } + + uint64 Properties() const { return 0ULL; } + + bool Compatible(const Fst &fst) const { return true; } + + static const string &Type() { + static const string *const type = new string("my"); + return *type; + } + + bool Write(std::ostream &strm) const { return true; } + + static CustomCompactor *Read(std::istream &strm) { + return new CustomCompactor; + } +}; + +REGISTER_FST(VectorFst, CustomArc); +REGISTER_FST(ConstFst, CustomArc); +static fst::FstRegisterer>> + CompactFst_StdArc_CustomCompactor_registerer; +static fst::FstRegisterer>> + CompactFst_CustomArc_CustomCompactor_registerer; +static fst::FstRegisterer> + ConstFst_StdArc_uint16_registerer; +static fst::FstRegisterer< + CompactFst, uint16>> + CompactFst_StdArc_CustomCompactor_uint16_registerer; + +} // namespace +} // namespace fst + +using fst::FstTester; +using fst::VectorFst; +using fst::ConstFst; +using fst::MatcherFst; +using fst::CompactFst; +using fst::Fst; +using fst::StdArc; +using fst::CustomArc; +using fst::CustomCompactor; +using fst::StdArcLookAheadFst; +using fst::EditFst; + +int main(int argc, char **argv) { + FLAGS_fst_verify_properties = true; + std::set_new_handler(FailedNewHandler); + SET_FLAGS(argv[0], &argc, &argv, true); + + // VectorFst tests + { + FstTester> std_vector_tester; + std_vector_tester.TestBase(); + std_vector_tester.TestExpanded(); + std_vector_tester.TestAssign(); + std_vector_tester.TestCopy(); + std_vector_tester.TestIO(); + std_vector_tester.TestMutable(); + } + + // ConstFst tests + { + FstTester> std_const_tester; + std_const_tester.TestBase(); + std_const_tester.TestExpanded(); + std_const_tester.TestCopy(); + std_const_tester.TestIO(); + } + + // CompactFst> + { + FstTester>> std_compact_tester; + std_compact_tester.TestBase(); + std_compact_tester.TestExpanded(); + std_compact_tester.TestCopy(); + std_compact_tester.TestIO(); + } + + // VectorFst tests + { + FstTester> std_vector_tester; + std_vector_tester.TestBase(); + std_vector_tester.TestExpanded(); + std_vector_tester.TestAssign(); + std_vector_tester.TestCopy(); + std_vector_tester.TestIO(); + std_vector_tester.TestMutable(); + } + + // ConstFst tests + { + FstTester> std_const_tester; + std_const_tester.TestBase(); + std_const_tester.TestExpanded(); + std_const_tester.TestCopy(); + std_const_tester.TestIO(); + } + + // CompactFst> + { + FstTester>> + std_compact_tester; + std_compact_tester.TestBase(); + std_compact_tester.TestExpanded(); + std_compact_tester.TestCopy(); + std_compact_tester.TestIO(); + } + + // ConstFst tests + { + FstTester> std_const_tester; + std_const_tester.TestBase(); + std_const_tester.TestExpanded(); + std_const_tester.TestCopy(); + std_const_tester.TestIO(); + } + + // CompactFst, uint16> + { + FstTester, uint16>> + std_compact_tester; + std_compact_tester.TestBase(); + std_compact_tester.TestExpanded(); + std_compact_tester.TestCopy(); + std_compact_tester.TestIO(); + } + + // FstTester + { + FstTester std_matcher_tester; + std_matcher_tester.TestBase(); + std_matcher_tester.TestExpanded(); + std_matcher_tester.TestCopy(); + } + + // EditFst tests + { + FstTester> std_edit_tester; + std_edit_tester.TestBase(); + std_edit_tester.TestExpanded(); + std_edit_tester.TestAssign(); + std_edit_tester.TestCopy(); + std_edit_tester.TestMutable(); + } + + std::cout << "PASS" << std::endl; + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/fst_test.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/fst_test.h new file mode 100644 index 0000000000..7d536d9012 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/fst_test.h @@ -0,0 +1,318 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Regression test for FST classes. + +#ifndef FST_TEST_FST_TEST_H_ +#define FST_TEST_FST_TEST_H_ + +#include +#include +#include +#include +#include + +DECLARE_string(tmpdir); + +namespace fst { + +// This tests an Fst F that is assumed to have a copy method from an +// arbitrary Fst. Some test functions make further assumptions mostly +// obvious from their name. These tests are written as member temple +// functions that take a test fst as its argument so that different +// Fsts in the interface hierarchy can be tested separately and so +// that we can instantiate only those tests that make sense for a +// particular Fst. +template +class FstTester { + public: + typedef typename F::Arc Arc; + typedef typename Arc::StateId StateId; + typedef typename Arc::Weight Weight; + typedef typename Arc::Label Label; + + FstTester() { + VectorFst vfst; + InitFst(&vfst, 128); + testfst_ = new F(vfst); + } + + explicit FstTester(F *testfst) : testfst_(testfst) {} + + ~FstTester() { delete testfst_; } + + // This verifies the contents described in InitFst() using + // methods defined in a generic Fst. + template + void TestBase(const G &fst) const { + CHECK(Verify(fst)); + CHECK_EQ(fst.Start(), 0); + StateId ns = 0; + StateIterator siter(fst); + Matcher matcher(fst, MATCH_INPUT); + MatchType match_type = matcher.Type(true); + for (; !siter.Done(); siter.Next()) { + } + for (siter.Reset(); !siter.Done(); siter.Next()) { + StateId s = siter.Value(); + matcher.SetState(s); + CHECK_EQ(fst.Final(s), NthWeight(s)); + size_t na = 0; + ArcIterator aiter(fst, s); + for (; !aiter.Done(); aiter.Next()) { + } + for (aiter.Reset(); !aiter.Done(); aiter.Next()) { + ++na; + const Arc &arc = aiter.Value(); + CHECK_EQ(arc.ilabel, na); + CHECK_EQ(arc.olabel, 0); + CHECK_EQ(arc.weight, NthWeight(na)); + CHECK_EQ(arc.nextstate, s); + if (match_type == MATCH_INPUT) { + CHECK(matcher.Find(arc.ilabel)); + CHECK_EQ(matcher.Value().ilabel, arc.ilabel); + } + } + CHECK_EQ(na, s); + CHECK_EQ(na, aiter.Position()); + CHECK_EQ(fst.NumArcs(s), s); + CHECK_EQ(fst.NumInputEpsilons(s), 0); + CHECK_EQ(fst.NumOutputEpsilons(s), s); + CHECK(!matcher.Find(s + 1)); // out-of-range + CHECK(!matcher.Find(kNoLabel)); // no explicit epsilons + CHECK(matcher.Find(0)); + CHECK_EQ(matcher.Value().ilabel, kNoLabel); // implicit epsilon loop + ++ns; + } + CHECK(fst.Properties(kNotAcceptor, true)); + CHECK(fst.Properties(kOEpsilons, true)); + } + + void TestBase() const { TestBase(*testfst_); } + + // This verifies methods specfic to an ExpandedFst. + template + void TestExpanded(const G &fst) const { + StateId ns = 0; + for (StateIterator siter(fst); !siter.Done(); siter.Next()) { + ++ns; + } + CHECK_EQ(fst.NumStates(), ns); + CHECK(fst.Properties(kExpanded, false)); + } + + void TestExpanded() const { TestExpanded(*testfst_); } + + // This verifies methods specific to a MutableFst. + template + void TestMutable(G *fst) const { + for (StateIterator siter(*fst); !siter.Done(); siter.Next()) { + StateId s = siter.Value(); + size_t na = 0; + size_t ni = fst->NumInputEpsilons(s); + MutableArcIterator aiter(fst, s); + for (; !aiter.Done(); aiter.Next()) { + } + for (aiter.Reset(); !aiter.Done(); aiter.Next()) { + ++na; + Arc arc = aiter.Value(); + arc.ilabel = 0; + aiter.SetValue(arc); + arc = aiter.Value(); + CHECK_EQ(arc.ilabel, 0); + CHECK_EQ(fst->NumInputEpsilons(s), ni + 1); + arc.ilabel = na; + aiter.SetValue(arc); + CHECK_EQ(fst->NumInputEpsilons(s), ni); + } + } + + G *cfst1 = fst->Copy(); + cfst1->DeleteStates(); + CHECK_EQ(cfst1->NumStates(), 0); + delete cfst1; + + G *cfst2 = fst->Copy(); + for (StateIterator siter(*cfst2); !siter.Done(); siter.Next()) { + StateId s = siter.Value(); + cfst2->DeleteArcs(s); + CHECK_EQ(cfst2->NumArcs(s), 0); + CHECK_EQ(cfst2->NumInputEpsilons(s), 0); + CHECK_EQ(cfst2->NumOutputEpsilons(s), 0); + } + delete cfst2; + } + + void TestMutable() { TestMutable(testfst_); } + + // This verifies the copy methods. + template + void TestAssign(G *fst) const { + // Assignment from G + G afst1; + afst1 = *fst; + CHECK(Equal(*fst, afst1)); + + // Assignment from Fst + G afst2; + afst2 = *static_cast *>(fst); + CHECK(Equal(*fst, afst2)); + + // Assignment from self + afst2.operator=(afst2); + CHECK(Equal(*fst, afst2)); + } + + void TestAssign() { TestAssign(testfst_); } + + // This verifies the copy methods. + template + void TestCopy(const G &fst) const { + // Copy from G + G c1fst(fst); + TestBase(c1fst); + + // Copy from Fst + const G c2fst(static_cast &>(fst)); + TestBase(c2fst); + + // Copy from self + const G *c3fst = fst.Copy(); + TestBase(*c3fst); + delete c3fst; + } + + void TestCopy() const { TestCopy(*testfst_); } + + // This verifies the read/write methods. + template + void TestIO(const G &fst) const { + const string filename = FLAGS_tmpdir + "/test.fst"; + const string aligned = FLAGS_tmpdir + "/aligned.fst"; + { + // write/read + CHECK(fst.Write(filename)); + G *ffst = G::Read(filename); + CHECK(ffst); + TestBase(*ffst); + delete ffst; + } + + { + // generic read/cast/test + Fst *gfst = Fst::Read(filename); + CHECK(gfst); + G *dfst = static_cast(gfst); + TestBase(*dfst); + + // generic write/read/test + CHECK(gfst->Write(filename)); + Fst *hfst = Fst::Read(filename); + CHECK(hfst); + TestBase(*hfst); + delete gfst; + delete hfst; + } + + { + // check mmaping by first writing the file with the aligned attribute set + { + std::ofstream ostr(aligned); + FstWriteOptions opts; + opts.source = aligned; + opts.align = true; + CHECK(fst.Write(ostr, opts)); + } + std::ifstream istr(aligned); + FstReadOptions opts; + opts.mode = FstReadOptions::ReadMode("map"); + opts.source = aligned; + G *gfst = G::Read(istr, opts); + CHECK(gfst); + TestBase(*gfst); + delete gfst; + } + + // check mmaping of unaligned files to make sure it does not fail. + { + { + std::ofstream ostr(aligned); + FstWriteOptions opts; + opts.source = aligned; + opts.align = false; + CHECK(fst.Write(ostr, opts)); + } + std::ifstream istr(aligned); + FstReadOptions opts; + opts.mode = FstReadOptions::ReadMode("map"); + opts.source = aligned; + G *gfst = G::Read(istr, opts); + CHECK(gfst); + TestBase(*gfst); + delete gfst; + } + + // expanded write/read/test + if (fst.Properties(kExpanded, false)) { + ExpandedFst *efst = ExpandedFst::Read(filename); + CHECK(efst); + TestBase(*efst); + TestExpanded(*efst); + delete efst; + } + + // mutable write/read/test + if (fst.Properties(kMutable, false)) { + MutableFst *mfst = MutableFst::Read(filename); + CHECK(mfst); + TestBase(*mfst); + TestExpanded(*mfst); + TestMutable(mfst); + delete mfst; + } + } + + void TestIO() const { TestIO(*testfst_); } + + private: + // This constructs test FSTs. Given a mutable FST, will leave + // the FST as follows: + // (I) NumStates() = nstates + // (II) Start() = 0 + // (III) Final(s) = NthWeight(s) + // (IV) For state s: + // (a) NumArcs(s) == s + // (b) For ith arc of s: + // (1) ilabel = i + // (2) olabel = 0 + // (3) weight = NthWeight(i) + // (4) nextstate = s + void InitFst(MutableFst *fst, size_t nstates) const { + fst->DeleteStates(); + CHECK_GT(nstates, 0); + + for (StateId s = 0; s < nstates; ++s) { + fst->AddState(); + fst->SetFinal(s, NthWeight(s)); + for (size_t i = 1; i <= s; ++i) { + Arc arc(i, 0, NthWeight(i), s); + fst->AddArc(s, arc); + } + } + + fst->SetStart(0); + } + + // Generates One() + ... + One() (n times) + Weight NthWeight(int n) const { + Weight w = Weight::Zero(); + for (int i = 0; i < n; ++i) w = Plus(w, Weight::One()); + return w; + } + + F *testfst_; // what we're testing +}; + +} // namespace fst + +#endif // FST_TEST_FST_TEST_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/rand-fst.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/rand-fst.h new file mode 100644 index 0000000000..f2f34c6710 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/rand-fst.h @@ -0,0 +1,90 @@ +#ifndef FST_TEST_RAND_FST_H_ +#define FST_TEST_RAND_FST_H_ + +#include +#include +#include + +namespace fst { + +// Generates a random FST. +template +void RandFst(const int num_random_states, const int num_random_arcs, + const int num_random_labels, const float acyclic_prob, + WeightGenerator *weight_generator, MutableFst *fst) { + typedef typename Arc::Label Label; + typedef typename Arc::StateId StateId; + typedef typename Arc::Weight Weight; + + // Determines direction of the arcs wrt state numbering. This way we + // can force acyclicity when desired. + enum ArcDirection { + ANY_DIRECTION = 0, + FORWARD_DIRECTION = 1, + REVERSE_DIRECTION = 2, + NUM_DIRECTIONS = 3 + }; + + ArcDirection arc_direction = ANY_DIRECTION; + if (rand() / (RAND_MAX + 1.0) < acyclic_prob) + arc_direction = rand() % 2 ? FORWARD_DIRECTION : REVERSE_DIRECTION; + + fst->DeleteStates(); + StateId ns = rand() % num_random_states; + + if (ns == 0) return; + for (StateId s = 0; s < ns; ++s) fst->AddState(); + + StateId start = rand() % ns; + fst->SetStart(start); + + size_t na = rand() % num_random_arcs; + for (size_t n = 0; n < na; ++n) { + StateId s = rand() % ns; + Arc arc; + arc.ilabel = rand() % num_random_labels; + arc.olabel = rand() % num_random_labels; + arc.weight = (*weight_generator)(); + arc.nextstate = rand() % ns; + + if ((arc_direction == FORWARD_DIRECTION || + arc_direction == REVERSE_DIRECTION) && + s == arc.nextstate) { + continue; // skips self-loops + } + + if ((arc_direction == FORWARD_DIRECTION && s > arc.nextstate) || + (arc_direction == REVERSE_DIRECTION && s < arc.nextstate)) { + StateId t = s; // reverses arcs + s = arc.nextstate; + arc.nextstate = t; + } + + fst->AddArc(s, arc); + } + + StateId nf = rand() % (ns + 1); + for (StateId n = 0; n < nf; ++n) { + StateId s = rand() % ns; + Weight final = (*weight_generator)(); + fst->SetFinal(s, final); + } + VLOG(1) << "Check FST for sanity (including property bits)."; + CHECK(Verify(*fst)); + + // Get/compute all properties. + uint64 props = fst->Properties(kFstProperties, true); + + // Select random set of properties to be unknown. + uint64 mask = 0; + for (int n = 0; n < 8; ++n) { + mask |= rand() & 0xff; + mask <<= 8; + } + mask &= ~kTrinaryProperties; + fst->SetProperties(props & ~mask, mask); +} + +} // namespace fst + +#endif // FST_TEST_RAND_FST_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/weight-tester.h b/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/weight-tester.h new file mode 100644 index 0000000000..b7de665e79 --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/weight-tester.h @@ -0,0 +1,207 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Utility class for regression testing of FST weights. + +#ifndef FST_TEST_WEIGHT_TESTER_H_ +#define FST_TEST_WEIGHT_TESTER_H_ + +#include +#include + +#include + +#include +#include + +namespace fst { + +// This class tests a variety of identities and properties that must +// hold for the Weight class to be well-defined. It calls function object +// WEIGHT_GENERATOR to select weights that are used in the tests. +template +class WeightTester { + public: + WeightTester(WeightGenerator generator) + : weight_generator_(std::move(generator)) {} + + void Test(int iterations, bool test_division = true) { + for (int i = 0; i < iterations; ++i) { + // Selects the test weights. + const Weight w1(weight_generator_()); + const Weight w2(weight_generator_()); + const Weight w3(weight_generator_()); + + VLOG(1) << "weight type = " << Weight::Type(); + VLOG(1) << "w1 = " << w1; + VLOG(1) << "w2 = " << w2; + VLOG(1) << "w3 = " << w3; + + TestSemiring(w1, w2, w3); + if (test_division) TestDivision(w1, w2); + TestReverse(w1, w2); + TestEquality(w1, w2, w3); + TestIO(w1); + TestCopy(w1); + } + } + + private: + // Note in the tests below we use ApproxEqual rather than == and add + // kDelta to inequalities where the weights might be inexact. + + // Tests (Plus, Times, Zero, One) defines a commutative semiring. + void TestSemiring(Weight w1, Weight w2, Weight w3) { + // Checks that the operations are closed. + CHECK(Plus(w1, w2).Member()); + CHECK(Times(w1, w2).Member()); + + // Checks that the operations are associative. + CHECK(ApproxEqual(Plus(w1, Plus(w2, w3)), Plus(Plus(w1, w2), w3))); + CHECK(ApproxEqual(Times(w1, Times(w2, w3)), Times(Times(w1, w2), w3))); + + // Checks the identity elements. + CHECK(Plus(w1, Weight::Zero()) == w1); + CHECK(Plus(Weight::Zero(), w1) == w1); + CHECK(Times(w1, Weight::One()) == w1); + CHECK(Times(Weight::One(), w1) == w1); + + // Check the no weight element. + CHECK(!Weight::NoWeight().Member()); + CHECK(!Plus(w1, Weight::NoWeight()).Member()); + CHECK(!Plus(Weight::NoWeight(), w1).Member()); + CHECK(!Times(w1, Weight::NoWeight()).Member()); + CHECK(!Times(Weight::NoWeight(), w1).Member()); + + // Checks that the operations commute. + CHECK(ApproxEqual(Plus(w1, w2), Plus(w2, w1))); + + if (Weight::Properties() & kCommutative) + CHECK(ApproxEqual(Times(w1, w2), Times(w2, w1))); + + // Checks Zero() is the annihilator. + CHECK(Times(w1, Weight::Zero()) == Weight::Zero()); + CHECK(Times(Weight::Zero(), w1) == Weight::Zero()); + + // Check Power(w, 0) is Weight::One() + CHECK(Power(w1, 0) == Weight::One()); + + // Check Power(w, 1) is w + CHECK(Power(w1, 1) == w1); + + // Check Power(w, 3) is Times(w, Times(w, w)) + CHECK(Power(w1, 3) == Times(w1, Times(w1, w1))); + + // Checks distributivity. + if (Weight::Properties() & kLeftSemiring) { + CHECK(ApproxEqual(Times(w1, Plus(w2, w3)), + Plus(Times(w1, w2), Times(w1, w3)))); + } + if (Weight::Properties() & kRightSemiring) + CHECK(ApproxEqual(Times(Plus(w1, w2), w3), + Plus(Times(w1, w3), Times(w2, w3)))); + + if (Weight::Properties() & kIdempotent) CHECK(Plus(w1, w1) == w1); + + if (Weight::Properties() & kPath) + CHECK(Plus(w1, w2) == w1 || Plus(w1, w2) == w2); + + // Ensure weights form a left or right semiring. + CHECK(Weight::Properties() & (kLeftSemiring | kRightSemiring)); + + // Check when Times() is commutative that it is marked as a semiring. + if (Weight::Properties() & kCommutative) + CHECK(Weight::Properties() & kSemiring); + } + + // Tests division operation. + void TestDivision(Weight w1, Weight w2) { + Weight p = Times(w1, w2); + + if (Weight::Properties() & kLeftSemiring) { + Weight d = Divide(p, w1, DIVIDE_LEFT); + if (d.Member()) CHECK(ApproxEqual(p, Times(w1, d))); + CHECK(!Divide(w1, Weight::NoWeight(), DIVIDE_LEFT).Member()); + CHECK(!Divide(Weight::NoWeight(), w1, DIVIDE_LEFT).Member()); + } + + if (Weight::Properties() & kRightSemiring) { + Weight d = Divide(p, w2, DIVIDE_RIGHT); + if (d.Member()) CHECK(ApproxEqual(p, Times(d, w2))); + CHECK(!Divide(w1, Weight::NoWeight(), DIVIDE_RIGHT).Member()); + CHECK(!Divide(Weight::NoWeight(), w1, DIVIDE_RIGHT).Member()); + } + + if (Weight::Properties() & kCommutative) { + Weight d = Divide(p, w1, DIVIDE_RIGHT); + if (d.Member()) CHECK(ApproxEqual(p, Times(d, w1))); + } + } + + // Tests reverse operation. + void TestReverse(Weight w1, Weight w2) { + typedef typename Weight::ReverseWeight ReverseWeight; + + ReverseWeight rw1 = w1.Reverse(); + ReverseWeight rw2 = w2.Reverse(); + + CHECK(rw1.Reverse() == w1); + CHECK(Plus(w1, w2).Reverse() == Plus(rw1, rw2)); + CHECK(Times(w1, w2).Reverse() == Times(rw2, rw1)); + } + + // Tests == is an equivalence relation. + void TestEquality(Weight w1, Weight w2, Weight w3) { + // Checks reflexivity. + CHECK(w1 == w1); + + // Checks symmetry. + CHECK((w1 == w2) == (w2 == w1)); + + // Checks transitivity. + if (w1 == w2 && w2 == w3) CHECK(w1 == w3); + } + + // Tests binary serialization and textual I/O. + void TestIO(Weight w) { + // Tests binary I/O + { + std::ostringstream os; + w.Write(os); + os.flush(); + std::istringstream is(os.str()); + Weight v; + v.Read(is); + CHECK_EQ(w, v); + } + + // Tests textual I/O. + { + std::ostringstream os; + os << w; + std::istringstream is(os.str()); + Weight v(Weight::One()); + is >> v; + CHECK(ApproxEqual(w, v)); + } + } + + // Tests copy constructor and assignment operator + void TestCopy(Weight w) { + Weight x = w; + CHECK(w == x); + + x = Weight(w); + CHECK(w == x); + + x.operator=(x); + CHECK(w == x); + } + + // Generates weights used in testing. + WeightGenerator weight_generator_; +}; + +} // namespace fst + +#endif // FST_TEST_WEIGHT_TESTER_H_ diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/weight_test.cc b/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/weight_test.cc new file mode 100644 index 0000000000..1d46d029ac --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/src/test/weight_test.cc @@ -0,0 +1,493 @@ +// See www.openfst.org for extensive documentation on this weighted +// finite-state transducer library. +// +// Regression test for FST weights. + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "./weight-tester.h" + +DEFINE_int32(seed, -1, "random seed"); +DEFINE_int32(repeat, 10000, "number of test repetitions"); + +namespace { + +using fst::Adder; +using fst::ExpectationWeight; +using fst::GALLIC; +using fst::GallicWeight; +using fst::LexicographicWeight; +using fst::LogWeight; +using fst::LogWeightTpl; +using fst::MinMaxWeight; +using fst::MinMaxWeightTpl; +using fst::NaturalLess; +using fst::PowerWeight; +using fst::ProductWeight; +using fst::SetWeight; +using fst::SET_INTERSECT_UNION; +using fst::SET_UNION_INTERSECT; +using fst::SET_BOOLEAN; +using fst::SignedLogWeight; +using fst::SignedLogWeightTpl; +using fst::SparsePowerWeight; +using fst::StringWeight; +using fst::STRING_LEFT; +using fst::STRING_RIGHT; +using fst::TropicalWeight; +using fst::TropicalWeightTpl; +using fst::UnionWeight; +using fst::WeightConvert; +using fst::WeightGenerate; +using fst::WeightTester; + +template +void TestTemplatedWeights(int repeat) { + using TropicalWeightGenerate = WeightGenerate>; + TropicalWeightGenerate tropical_generate; + WeightTester, TropicalWeightGenerate> tropical_tester( + tropical_generate); + tropical_tester.Test(repeat); + + using LogWeightGenerate = WeightGenerate>; + LogWeightGenerate log_generate; + WeightTester, LogWeightGenerate> log_tester(log_generate); + log_tester.Test(repeat); + + using MinMaxWeightGenerate = WeightGenerate>; + MinMaxWeightGenerate minmax_generate(true); + WeightTester, MinMaxWeightGenerate> minmax_tester( + minmax_generate); + minmax_tester.Test(repeat); + + using SignedLogWeightGenerate = WeightGenerate>; + SignedLogWeightGenerate signedlog_generate; + WeightTester, SignedLogWeightGenerate> + signedlog_tester(signedlog_generate); + signedlog_tester.Test(repeat); +} + +template +void TestAdder(int n) { + Weight sum = Weight::Zero(); + Adder adder; + for (int i = 0; i < n; ++i) { + sum = Plus(sum, Weight::One()); + adder.Add(Weight::One()); + } + CHECK(ApproxEqual(sum, adder.Sum())); +} + +template +void TestSignedAdder(int n) { + Weight sum = Weight::Zero(); + Adder adder; + const Weight minus_one = Minus(Weight::Zero(), Weight::One()); + for (int i = 0; i < n; ++i) { + if (i < n/4 || i > 3*n/4) { + sum = Plus(sum, Weight::One()); + adder.Add(Weight::One()); + } else { + sum = Minus(sum, Weight::One()); + adder.Add(minus_one); + } + } + CHECK(ApproxEqual(sum, adder.Sum())); +} + +template +void TestWeightConversion(Weight1 w1) { + // Tests round-trp conversion. + WeightConvert to_w1_; + WeightConvert to_w2_; + Weight2 w2 = to_w2_(w1); + Weight1 nw1 = to_w1_(w2); + CHECK_EQ(w1, nw1); +} + +template +void TestWeightCopy(FromWeight w) { + // Test copy constructor. + const ToWeight to_copied(w); + const FromWeight roundtrip_copied(to_copied); + CHECK_EQ(w, roundtrip_copied); + + // Test copy assign. + ToWeight to_copy_assigned; + to_copy_assigned = w; + CHECK_EQ(to_copied, to_copy_assigned); + + FromWeight roundtrip_copy_assigned; + roundtrip_copy_assigned = to_copy_assigned; + CHECK_EQ(w, roundtrip_copy_assigned); +} + +template +void TestWeightMove(FromWeight w) { + // Assume FromWeight -> FromWeight copy works. + const FromWeight orig(w); + ToWeight to_moved(std::move(w)); + const FromWeight roundtrip_moved(std::move(to_moved)); + CHECK_EQ(orig, roundtrip_moved); + + // Test move assign. + w = orig; + ToWeight to_move_assigned; + to_move_assigned = std::move(w); + FromWeight roundtrip_move_assigned; + roundtrip_move_assigned = std::move(to_move_assigned); + CHECK_EQ(orig, roundtrip_move_assigned); +} + +template +void TestImplicitConversion() { + // Only test a few of the operations; assumes they are implemented with the + // same pattern. + CHECK(Weight(2.0f) == 2.0f); + CHECK(Weight(2.0) == 2.0); + CHECK(2.0f == Weight(2.0f)); + CHECK(2.0 == Weight(2.0)); + + CHECK_EQ(Weight::Zero(), Times(Weight::Zero(), 3.0f)); + CHECK_EQ(Weight::Zero(), Times(Weight::Zero(), 3.0)); + CHECK_EQ(Weight::Zero(), Times(3.0, Weight::Zero())); + + CHECK_EQ(Weight(3.0), Plus(Weight::Zero(), 3.0f)); + CHECK_EQ(Weight(3.0), Plus(Weight::Zero(), 3.0)); + CHECK_EQ(Weight(3.0), Plus(3.0, Weight::Zero())); +} + +void TestPowerWeightGetSetValue() { + PowerWeight w; + // LogWeight has unspecified initial value, so don't check it. + w.SetValue(0, LogWeight(2)); + w.SetValue(1, LogWeight(3)); + CHECK_EQ(LogWeight(2), w.Value(0)); + CHECK_EQ(LogWeight(3), w.Value(1)); +} + +void TestSparsePowerWeightGetSetValue() { + const LogWeight default_value(17); + SparsePowerWeight w; + w.SetDefaultValue(default_value); + + // All gets should be the default. + CHECK_EQ(default_value, w.Value(0)); + CHECK_EQ(default_value, w.Value(100)); + + // First set should fill first_. + w.SetValue(10, LogWeight(10)); + CHECK_EQ(LogWeight(10), w.Value(10)); + w.SetValue(10, LogWeight(20)); + CHECK_EQ(LogWeight(20), w.Value(10)); + + // Add a smaller index. + w.SetValue(5, LogWeight(5)); + CHECK_EQ(LogWeight(5), w.Value(5)); + CHECK_EQ(LogWeight(20), w.Value(10)); + + // Add some larger indices. + w.SetValue(30, LogWeight(30)); + CHECK_EQ(LogWeight(5), w.Value(5)); + CHECK_EQ(LogWeight(20), w.Value(10)); + CHECK_EQ(LogWeight(30), w.Value(30)); + + w.SetValue(29, LogWeight(29)); + CHECK_EQ(LogWeight(5), w.Value(5)); + CHECK_EQ(LogWeight(20), w.Value(10)); + CHECK_EQ(LogWeight(29), w.Value(29)); + CHECK_EQ(LogWeight(30), w.Value(30)); + + w.SetValue(31, LogWeight(31)); + CHECK_EQ(LogWeight(5), w.Value(5)); + CHECK_EQ(LogWeight(20), w.Value(10)); + CHECK_EQ(LogWeight(29), w.Value(29)); + CHECK_EQ(LogWeight(30), w.Value(30)); + CHECK_EQ(LogWeight(31), w.Value(31)); + + // Replace a value. + w.SetValue(30, LogWeight(60)); + CHECK_EQ(LogWeight(60), w.Value(30)); + + // Replace a value with the default. + CHECK_EQ(5, w.Size()); + w.SetValue(30, default_value); + CHECK_EQ(default_value, w.Value(30)); + CHECK_EQ(4, w.Size()); + + // Replace lowest index by the default value. + w.SetValue(5, default_value); + CHECK_EQ(default_value, w.Value(5)); + CHECK_EQ(3, w.Size()); + + // Clear out everything. + w.SetValue(31, default_value); + w.SetValue(29, default_value); + w.SetValue(10, default_value); + CHECK_EQ(0, w.Size()); + + CHECK_EQ(default_value, w.Value(5)); + CHECK_EQ(default_value, w.Value(10)); + CHECK_EQ(default_value, w.Value(29)); + CHECK_EQ(default_value, w.Value(30)); + CHECK_EQ(default_value, w.Value(31)); +} + +} // namespace + +int main(int argc, char **argv) { + std::set_new_handler(FailedNewHandler); + SET_FLAGS(argv[0], &argc, &argv, true); + + LOG(INFO) << "Seed = " << FLAGS_seed; + srand(FLAGS_seed); + + TestTemplatedWeights(FLAGS_repeat); + TestTemplatedWeights(FLAGS_repeat); + FLAGS_fst_weight_parentheses = "()"; + TestTemplatedWeights(FLAGS_repeat); + TestTemplatedWeights(FLAGS_repeat); + FLAGS_fst_weight_parentheses = ""; + + // Makes sure type names for templated weights are consistent. + CHECK(TropicalWeight::Type() == "tropical"); + CHECK(TropicalWeightTpl::Type() != TropicalWeightTpl::Type()); + CHECK(LogWeight::Type() == "log"); + CHECK(LogWeightTpl::Type() != LogWeightTpl::Type()); + TropicalWeightTpl w(2.0); + TropicalWeight tw(2.0); + + TestAdder(1000); + TestAdder(1000); + TestSignedAdder(1000); + + TestImplicitConversion(); + TestImplicitConversion(); + TestImplicitConversion(); + + TestWeightConversion(2.0); + + using LeftStringWeight = StringWeight; + using LeftStringWeightGenerate = WeightGenerate; + LeftStringWeightGenerate left_string_generate; + WeightTester left_string_tester( + left_string_generate); + left_string_tester.Test(FLAGS_repeat); + + using RightStringWeight = StringWeight; + using RightStringWeightGenerate = WeightGenerate; + RightStringWeightGenerate right_string_generate; + WeightTester + right_string_tester(right_string_generate); + right_string_tester.Test(FLAGS_repeat); + + // STRING_RESTRICT not tested since it requires equal strings, + // so would fail. + + using IUSetWeight = SetWeight; + using IUSetWeightGenerate = WeightGenerate; + IUSetWeightGenerate iu_set_generate; + WeightTester + iu_set_tester(iu_set_generate); + iu_set_tester.Test(FLAGS_repeat); + + using UISetWeight = SetWeight; + using UISetWeightGenerate = WeightGenerate; + UISetWeightGenerate ui_set_generate; + WeightTester + ui_set_tester(ui_set_generate); + ui_set_tester.Test(FLAGS_repeat); + + // SET_INTERSECT_UNION_RESTRICT not tested since it requires equal sets, + // so would fail. + + using BoolSetWeight = SetWeight; + using BoolSetWeightGenerate = WeightGenerate; + BoolSetWeightGenerate bool_set_generate; + WeightTester + bool_set_tester(bool_set_generate); + bool_set_tester.Test(FLAGS_repeat); + + TestWeightConversion(iu_set_generate()); + + TestWeightCopy(iu_set_generate()); + TestWeightCopy(iu_set_generate()); + TestWeightCopy(ui_set_generate()); + TestWeightCopy(ui_set_generate()); + TestWeightCopy(bool_set_generate()); + TestWeightCopy(bool_set_generate()); + + TestWeightMove(iu_set_generate()); + TestWeightMove(iu_set_generate()); + TestWeightMove(ui_set_generate()); + TestWeightMove(ui_set_generate()); + TestWeightMove(bool_set_generate()); + TestWeightMove(bool_set_generate()); + + // COMPOSITE WEIGHTS AND TESTERS - DEFINITIONS + + using TropicalGallicWeight = GallicWeight; + using TropicalGallicWeightGenerate = WeightGenerate; + TropicalGallicWeightGenerate tropical_gallic_generate(true); + WeightTester + tropical_gallic_tester(tropical_gallic_generate); + + using TropicalGenGallicWeight = GallicWeight; + using TropicalGenGallicWeightGenerate = + WeightGenerate; + TropicalGenGallicWeightGenerate tropical_gen_gallic_generate(false); + WeightTester + tropical_gen_gallic_tester(tropical_gen_gallic_generate); + + using TropicalProductWeight = ProductWeight; + using TropicalProductWeightGenerate = WeightGenerate; + TropicalProductWeightGenerate tropical_product_generate; + WeightTester + tropical_product_tester(tropical_product_generate); + + using TropicalLexicographicWeight = + LexicographicWeight; + using TropicalLexicographicWeightGenerate = + WeightGenerate; + TropicalLexicographicWeightGenerate tropical_lexicographic_generate; + WeightTester + tropical_lexicographic_tester(tropical_lexicographic_generate); + + using TropicalCubeWeight = PowerWeight; + using TropicalCubeWeightGenerate = WeightGenerate; + TropicalCubeWeightGenerate tropical_cube_generate; + WeightTester + tropical_cube_tester(tropical_cube_generate); + + using FirstNestedProductWeight = + ProductWeight; + using FirstNestedProductWeightGenerate = + WeightGenerate; + FirstNestedProductWeightGenerate first_nested_product_generate; + WeightTester + first_nested_product_tester(first_nested_product_generate); + + using SecondNestedProductWeight = + ProductWeight; + using SecondNestedProductWeightGenerate = + WeightGenerate; + SecondNestedProductWeightGenerate second_nested_product_generate; + WeightTester + second_nested_product_tester(second_nested_product_generate); + + using NestedProductCubeWeight = PowerWeight; + using NestedProductCubeWeightGenerate = + WeightGenerate; + NestedProductCubeWeightGenerate nested_product_cube_generate; + WeightTester + nested_product_cube_tester(nested_product_cube_generate); + + using SparseNestedProductCubeWeight = + SparsePowerWeight; + using SparseNestedProductCubeWeightGenerate = + WeightGenerate; + SparseNestedProductCubeWeightGenerate sparse_nested_product_cube_generate; + WeightTester + sparse_nested_product_cube_tester(sparse_nested_product_cube_generate); + + using LogSparsePowerWeight = SparsePowerWeight; + using LogSparsePowerWeightGenerate = WeightGenerate; + LogSparsePowerWeightGenerate log_sparse_power_generate; + WeightTester + log_sparse_power_tester(log_sparse_power_generate); + + using LogLogExpectationWeight = ExpectationWeight; + using LogLogExpectationWeightGenerate = + WeightGenerate; + LogLogExpectationWeightGenerate log_log_expectation_generate; + WeightTester + log_log_expectation_tester(log_log_expectation_generate); + + using LogLogSparseExpectationWeight = + ExpectationWeight; + using LogLogSparseExpectationWeightGenerate = + WeightGenerate; + LogLogSparseExpectationWeightGenerate log_log_sparse_expectation_generate; + WeightTester + log_log_sparse_expectation_tester(log_log_sparse_expectation_generate); + + struct UnionWeightOptions { + using Compare = NaturalLess; + + struct Merge { + TropicalWeight operator()(const TropicalWeight &w1, + const TropicalWeight &w2) const { + return w1; + } + }; + + using ReverseOptions = UnionWeightOptions; + }; + + using TropicalUnionWeight = UnionWeight; + using TropicalUnionWeightGenerate = WeightGenerate; + TropicalUnionWeightGenerate tropical_union_generate; + WeightTester + tropical_union_tester(tropical_union_generate); + + // COMPOSITE WEIGHTS AND TESTERS - TESTING + + // Tests composite weight I/O with parentheses. + FLAGS_fst_weight_parentheses = "()"; + + // Unnested composite. + tropical_gallic_tester.Test(FLAGS_repeat); + tropical_gen_gallic_tester.Test(FLAGS_repeat); + tropical_product_tester.Test(FLAGS_repeat); + tropical_lexicographic_tester.Test(FLAGS_repeat); + tropical_cube_tester.Test(FLAGS_repeat); + log_sparse_power_tester.Test(FLAGS_repeat); + log_log_expectation_tester.Test(FLAGS_repeat, false); + tropical_union_tester.Test(FLAGS_repeat, false); + + // Nested composite. + first_nested_product_tester.Test(FLAGS_repeat); + second_nested_product_tester.Test(5); + nested_product_cube_tester.Test(FLAGS_repeat); + sparse_nested_product_cube_tester.Test(FLAGS_repeat); + log_log_sparse_expectation_tester.Test(FLAGS_repeat, false); + + // ... and tests composite weight I/O without parentheses. + FLAGS_fst_weight_parentheses = ""; + + // Unnested composite. + tropical_gallic_tester.Test(FLAGS_repeat); + tropical_product_tester.Test(FLAGS_repeat); + tropical_lexicographic_tester.Test(FLAGS_repeat); + tropical_cube_tester.Test(FLAGS_repeat); + log_sparse_power_tester.Test(FLAGS_repeat); + log_log_expectation_tester.Test(FLAGS_repeat, false); + tropical_union_tester.Test(FLAGS_repeat, false); + + // Nested composite. + second_nested_product_tester.Test(FLAGS_repeat); + log_log_sparse_expectation_tester.Test(FLAGS_repeat, false); + + TestPowerWeightGetSetValue(); + TestSparsePowerWeightGetSetValue(); + + std::cout << "PASS" << std::endl; + + return 0; +} diff --git a/native_client/ctcdecode/third_party/openfst-1.6.7/test-driver b/native_client/ctcdecode/third_party/openfst-1.6.7/test-driver new file mode 100755 index 0000000000..d30605660a --- /dev/null +++ b/native_client/ctcdecode/third_party/openfst-1.6.7/test-driver @@ -0,0 +1,139 @@ +#! /bin/sh +# test-driver - basic testsuite driver script. + +scriptversion=2013-07-13.22; # UTC + +# Copyright (C) 2011-2013 Free Software Foundation, Inc. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, or (at your option) +# any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +# This file is maintained in Automake, please report +# bugs to or send patches to +# . + +# Make unconditional expansion of undefined variables an error. This +# helps a lot in preventing typo-related bugs. +set -u + +usage_error () +{ + echo "$0: $*" >&2 + print_usage >&2 + exit 2 +} + +print_usage () +{ + cat <$log_file 2>&1 +estatus=$? +if test $enable_hard_errors = no && test $estatus -eq 99; then + estatus=1 +fi + +case $estatus:$expect_failure in + 0:yes) col=$red res=XPASS recheck=yes gcopy=yes;; + 0:*) col=$grn res=PASS recheck=no gcopy=no;; + 77:*) col=$blu res=SKIP recheck=no gcopy=yes;; + 99:*) col=$mgn res=ERROR recheck=yes gcopy=yes;; + *:yes) col=$lgn res=XFAIL recheck=no gcopy=yes;; + *:*) col=$red res=FAIL recheck=yes gcopy=yes;; +esac + +# Report outcome to console. +echo "${col}${res}${std}: $test_name" + +# Register the test result, and other relevant metadata. +echo ":test-result: $res" > $trs_file +echo ":global-test-result: $res" >> $trs_file +echo ":recheck: $recheck" >> $trs_file +echo ":copy-in-global-log: $gcopy" >> $trs_file + +# Local Variables: +# mode: shell-script +# sh-indentation: 2 +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "scriptversion=" +# time-stamp-format: "%:y-%02m-%02d.%02H" +# time-stamp-time-zone: "UTC" +# time-stamp-end: "; # UTC" +# End: diff --git a/native_client/deepspeech.cc b/native_client/deepspeech.cc index 5714496cb5..ff6499a780 100644 --- a/native_client/deepspeech.cc +++ b/native_client/deepspeech.cc @@ -2,11 +2,11 @@ #include #include #include +#include #include #include "deepspeech.h" #include "alphabet.h" -#include "beam_search.h" #include "tensorflow/core/public/version.h" #include "native_client/ds_version.h" @@ -17,6 +17,8 @@ #include "c_speech_features.h" +#include "ctcdecode/ctc_beam_search_decoder.h" + //TODO: infer batch size from model/use dynamic batch size const unsigned int BATCH_SIZE = 1; @@ -37,8 +39,6 @@ const unsigned int LOWFREQ = 0; const unsigned int CEP_LIFTER = 22; using namespace tensorflow; -using tensorflow::ctc::CTCBeamSearchDecoder; -using tensorflow::ctc::CTCDecoder; using std::vector; @@ -98,7 +98,7 @@ struct ModelState { unsigned int ncep; unsigned int ncontext; Alphabet* alphabet; - KenLMBeamScorer* scorer; + Scorer* scorer; unsigned int beam_width; unsigned int n_steps; unsigned int mfcc_feats_per_timestep; @@ -177,7 +177,7 @@ StreamingState::feedAudioContent(const short* buffer, // If the buffer is full, process and shift it if (audio_buffer.size() == AUDIO_WIN_LEN_SAMPLES) { processAudioWindow(audio_buffer); - // Shift data by one step of 10ms + // Shift data by one step std::rotate(audio_buffer.begin(), audio_buffer.begin() + AUDIO_WIN_STEP_SAMPLES, audio_buffer.end()); audio_buffer.resize(audio_buffer.size() - AUDIO_WIN_STEP_SAMPLES); } @@ -320,55 +320,24 @@ ModelState::infer(const float* aMfcc, unsigned int n_frames, vector& logi char* ModelState::decode(vector& logits) { - const int top_paths = 1; + const int cutoff_top_n = 40; + const double cutoff_prob = 1.0; const size_t num_classes = alphabet->GetSize() + 1; // +1 for blank const int n_frames = logits.size() / (BATCH_SIZE * num_classes); - // Raw data containers (arrays of floats, ints, etc.). - int sequence_lengths[BATCH_SIZE] = {n_frames}; - - // Convert data containers to the format accepted by the decoder, simply - // mapping the memory from the container to an Eigen::ArrayXi,::MatrixXf, - // using Eigen::Map. - Eigen::Map seq_len(&sequence_lengths[0], BATCH_SIZE); - vector> inputs; - inputs.reserve(n_frames); + vector> inputs; + inputs.resize(n_frames); for (int t = 0; t < n_frames; ++t) { - inputs.emplace_back(&logits[t * BATCH_SIZE * num_classes], BATCH_SIZE, num_classes); - } - - // Prepare containers for output and scores. - // CTCDecoder::Output is vector> - vector decoder_outputs(top_paths); - for (CTCDecoder::Output& output : decoder_outputs) { - output.resize(BATCH_SIZE); - } - float score[BATCH_SIZE][top_paths] = {{0.0}}; - Eigen::Map scores(&score[0][0], BATCH_SIZE, top_paths); - - if (scorer == nullptr) { - CTCBeamSearchDecoder<>::DefaultBeamScorer default_scorer; - CTCBeamSearchDecoder<> decoder(num_classes, - beam_width, - &default_scorer, - BATCH_SIZE); - decoder.Decode(seq_len, inputs, &decoder_outputs, &scores).ok(); - } else { - CTCBeamSearchDecoder decoder(num_classes, - beam_width, - scorer, - BATCH_SIZE); - decoder.Decode(seq_len, inputs, &decoder_outputs, &scores).ok(); + for (int i = 0; i < num_classes; ++i) { + inputs[t].push_back(logits[t * num_classes + i]); + } } - // Output is an array of shape (batch_size, top_paths, result_length). - - std::stringstream output; - for (int64 character : decoder_outputs[0][0]) { - output << alphabet->StringFromLabel(character); - } + // Vector of pairs + vector> out = ctc_beam_search_decoder( + inputs, *alphabet, beam_width, cutoff_prob, cutoff_top_n, scorer); - return strdup(output.str().c_str()); + return strdup(alphabet->LabelsToString(out[0].second.tokens).c_str()); } int @@ -493,8 +462,10 @@ DS_EnableDecoderWithLM(ModelState* aCtx, float aValidWordCountWeight) { try { - aCtx->scorer = new KenLMBeamScorer(aLMPath, aTriePath, aAlphabetConfigPath, - aLMWeight, aValidWordCountWeight); + aCtx->scorer = new Scorer(aLMWeight, aValidWordCountWeight, + aLMPath ? aLMPath : "", + aTriePath ? aTriePath : "", + *aCtx->alphabet); return 0; } catch (...) { return 1; diff --git a/native_client/generate_trie.cpp b/native_client/generate_trie.cpp index ad894e1016..0beb9d4127 100644 --- a/native_client/generate_trie.cpp +++ b/native_client/generate_trie.cpp @@ -1,64 +1,25 @@ #include #include #include -using namespace std; -#include "lm/model.hh" -#include "trie_node.h" +#include "ctcdecode/scorer.h" +#include "fst/fstlib.h" #include "alphabet.h" -typedef lm::ngram::QuantArrayTrieModel Model; - -lm::WordIndex GetWordIndex(const Model& model, const std::string& word) { - return model.GetVocabulary().Index(word); -} - -float ScoreWord(const Model& model, lm::WordIndex word_index) { - // We don't need to keep state here as we're scoring the words individually. - Model::State out; - return model.FullScore(model.NullContextState(), word_index, out).prob; -} - -int generate_trie(const char* alphabet_path, const char* kenlm_path, const char* vocab_path, const char* trie_path) { - Alphabet a(alphabet_path); - - lm::ngram::Config config; - config.load_method = util::POPULATE_OR_READ; - Model model(kenlm_path, config); - TrieNode root(a.GetSize()); - - std::ifstream ifs(vocab_path, std::ifstream::in | std::ios::binary); - if (!ifs) { - std::cerr << "unable to open vocabulary file " << vocab_path << std::endl; - return -1; - } - - std::ofstream ofs(trie_path); - if (!ofs) { - std::cerr << "unable to open output file " << trie_path << std::endl; - return -1; - } - - std::string word; - while (ifs >> word) { - lm::WordIndex word_index = GetWordIndex(model, word); - float unigram_score = ScoreWord(model, word_index); - root.Insert(word, - [&a](const std::string& c) { - return a.LabelFromString(c); - }, - word_index, unigram_score); - } +using namespace std; - root.WriteToStream(ofs); +int generate_trie(const char* alphabet_path, const char* kenlm_path, const char* trie_path) { + Alphabet alphabet(alphabet_path); + Scorer scorer(0.0, 0.0, kenlm_path, "", alphabet); + scorer.save_dictionary(trie_path); return 0; } int main(int argc, char** argv) { - if (argc != 5) { - std::cerr << "Usage: " << argv[0] << " " << std::endl; + if (argc != 4) { + std::cerr << "Usage: " << argv[0] << " " << std::endl; return -1; } - return generate_trie(argv[1], argv[2], argv[3], argv[4]); + return generate_trie(argv[1], argv[2], argv[3]); } diff --git a/native_client/trie_load.cc b/native_client/trie_load.cc index 896d76c22b..ec0073c96b 100644 --- a/native_client/trie_load.cc +++ b/native_client/trie_load.cc @@ -1,22 +1,24 @@ +#include #include -#include #include +#include "ctcdecode/scorer.h" +#include "fst/fstlib.h" #include "alphabet.h" -#include "trie_node.h" + +using namespace std; + int main(int argc, char** argv) { - const char* trie_path = argv[1]; - const char* alphabet_path = argv[2]; + const char* kenlm_path = argv[1]; + const char* trie_path = argv[2]; + const char* alphabet_path = argv[3]; printf("Loading trie(%s) and alphabet(%s)\n", trie_path, alphabet_path); - Alphabet alphabet_ = Alphabet(alphabet_path); - TrieNode *trieRoot_; - - std::ifstream in(trie_path, std::ios::in | std::ios::binary); - TrieNode::ReadFromStream(in, trieRoot_, alphabet_.GetSize()); + Alphabet alphabet(alphabet_path); + Scorer scorer(0.0, 0.0, kenlm_path, trie_path, alphabet); return 0; } diff --git a/taskcluster/test-armbian-opt-base.tyml b/taskcluster/test-armbian-opt-base.tyml index 08b85c3d02..561072ffec 100644 --- a/taskcluster/test-armbian-opt-base.tyml +++ b/taskcluster/test-armbian-opt-base.tyml @@ -39,8 +39,8 @@ then: DEEPSPEECH_ARTIFACTS_ROOT: https://queue.taskcluster.net/v1/task/${linux_arm64_build}/artifacts/public DEEPSPEECH_NODEJS: https://queue.taskcluster.net/v1/task/${node_package}/artifacts/public DEEPSPEECH_TEST_MODEL: https://queue.taskcluster.net/v1/task/${training}/artifacts/public/output_graph.pb - DEEPSPEECH_PROD_MODEL: https://github.com/reuben/DeepSpeech/releases/download/v0.2.0-prod/output_graph.pb - DEEPSPEECH_PROD_MODEL_MMAP: https://github.com/reuben/DeepSpeech/releases/download/v0.2.0-prod/output_graph.pbmm + DEEPSPEECH_PROD_MODEL: https://github.com/reuben/DeepSpeech/releases/download/v0.2.0-prod-ctcdecode/output_graph.pb + DEEPSPEECH_PROD_MODEL_MMAP: https://github.com/reuben/DeepSpeech/releases/download/v0.2.0-prod-ctcdecode/output_graph.pbmm PIP_DEFAULT_TIMEOUT: "60" PIP_EXTRA_INDEX_URL: "https://lissyx.github.io/deepspeech-python-wheels/" EXTRA_PYTHON_CONFIGURE_OPTS: "--with-fpectl" # Required by Debian Stretch diff --git a/taskcluster/test-darwin-opt-base.tyml b/taskcluster/test-darwin-opt-base.tyml index e889ad401c..df787a896f 100644 --- a/taskcluster/test-darwin-opt-base.tyml +++ b/taskcluster/test-darwin-opt-base.tyml @@ -39,8 +39,8 @@ then: DEEPSPEECH_ARTIFACTS_ROOT: https://queue.taskcluster.net/v1/task/${darwin_amd64_build}/artifacts/public DEEPSPEECH_NODEJS: https://queue.taskcluster.net/v1/task/${node_package}/artifacts/public DEEPSPEECH_TEST_MODEL: https://queue.taskcluster.net/v1/task/${training}/artifacts/public/output_graph.pb - DEEPSPEECH_PROD_MODEL: https://github.com/reuben/DeepSpeech/releases/download/v0.2.0-prod/output_graph.pb - DEEPSPEECH_PROD_MODEL_MMAP: https://github.com/reuben/DeepSpeech/releases/download/v0.2.0-prod/output_graph.pbmm + DEEPSPEECH_PROD_MODEL: https://github.com/reuben/DeepSpeech/releases/download/v0.2.0-prod-ctcdecode/output_graph.pb + DEEPSPEECH_PROD_MODEL_MMAP: https://github.com/reuben/DeepSpeech/releases/download/v0.2.0-prod-ctcdecode/output_graph.pbmm EXPECTED_TENSORFLOW_VERSION: "TensorFlow: v1.11.0-11-gbee8254" command: diff --git a/taskcluster/test-linux-opt-base.tyml b/taskcluster/test-linux-opt-base.tyml index 37c3cf85b4..4a6cb52c02 100644 --- a/taskcluster/test-linux-opt-base.tyml +++ b/taskcluster/test-linux-opt-base.tyml @@ -41,8 +41,8 @@ then: DEEPSPEECH_NODEJS: https://queue.taskcluster.net/v1/task/${node_package}/artifacts/public DEEPSPEECH_LIBCTC: https://queue.taskcluster.net/v1/task/${linux_amd64_ctc}/artifacts/public/decoder.tar.xz DEEPSPEECH_TEST_MODEL: https://queue.taskcluster.net/v1/task/${training}/artifacts/public/output_graph.pb - DEEPSPEECH_PROD_MODEL: https://github.com/reuben/DeepSpeech/releases/download/v0.2.0-prod/output_graph.pb - DEEPSPEECH_PROD_MODEL_MMAP: https://github.com/reuben/DeepSpeech/releases/download/v0.2.0-prod/output_graph.pbmm + DEEPSPEECH_PROD_MODEL: https://github.com/reuben/DeepSpeech/releases/download/v0.2.0-prod-ctcdecode/output_graph.pb + DEEPSPEECH_PROD_MODEL_MMAP: https://github.com/reuben/DeepSpeech/releases/download/v0.2.0-prod-ctcdecode/output_graph.pbmm PIP_DEFAULT_TIMEOUT: "60" EXPECTED_TENSORFLOW_VERSION: "TensorFlow: v1.11.0-11-gbee8254" diff --git a/taskcluster/test-raspbian-opt-base.tyml b/taskcluster/test-raspbian-opt-base.tyml index f5d7484f69..f9fd9d60a0 100644 --- a/taskcluster/test-raspbian-opt-base.tyml +++ b/taskcluster/test-raspbian-opt-base.tyml @@ -39,8 +39,8 @@ then: DEEPSPEECH_ARTIFACTS_ROOT: https://queue.taskcluster.net/v1/task/${linux_rpi3_build}/artifacts/public DEEPSPEECH_NODEJS: https://queue.taskcluster.net/v1/task/${node_package}/artifacts/public DEEPSPEECH_TEST_MODEL: https://queue.taskcluster.net/v1/task/${training}/artifacts/public/output_graph.pb - DEEPSPEECH_PROD_MODEL: https://github.com/reuben/DeepSpeech/releases/download/v0.2.0-prod/output_graph.pb - DEEPSPEECH_PROD_MODEL_MMAP: https://github.com/reuben/DeepSpeech/releases/download/v0.2.0-prod/output_graph.pbmm + DEEPSPEECH_PROD_MODEL: https://github.com/reuben/DeepSpeech/releases/download/v0.2.0-prod-ctcdecode/output_graph.pb + DEEPSPEECH_PROD_MODEL_MMAP: https://github.com/reuben/DeepSpeech/releases/download/v0.2.0-prod-ctcdecode/output_graph.pbmm PIP_DEFAULT_TIMEOUT: "60" PIP_EXTRA_INDEX_URL: "https://www.piwheels.org/simple" EXTRA_PYTHON_CONFIGURE_OPTS: "--with-fpectl" # Required by Raspbian Stretch / PiWheels diff --git a/tc-tests-utils.sh b/tc-tests-utils.sh index e499941036..0540f839f2 100755 --- a/tc-tests-utils.sh +++ b/tc-tests-utils.sh @@ -153,12 +153,12 @@ assert_correct_multi_ldc93s1() assert_correct_ldc93s1_prodmodel() { - assert_correct_inference "$1" "she hadered or so and greasy wash war or year" + assert_correct_inference "$1" "she had out in greasy wash water all year" } assert_correct_ldc93s1_prodmodel_stereo_44k() { - assert_correct_inference "$1" "she had tered or so and greasy wash war or year" + assert_correct_inference "$1" "she had out and greasy wash water all year" } assert_correct_warning_upsampling() @@ -262,7 +262,7 @@ download_data() cp ${DS_ROOT_TASK}/DeepSpeech/ds/data/smoke_test/*.wav ${TASKCLUSTER_TMP_DIR}/ cp ${DS_ROOT_TASK}/DeepSpeech/ds/data/alphabet.txt ${TASKCLUSTER_TMP_DIR}/alphabet.txt cp ${DS_ROOT_TASK}/DeepSpeech/ds/data/smoke_test/vocab.pruned.lm ${TASKCLUSTER_TMP_DIR}/lm.binary - cp ${DS_ROOT_TASK}/DeepSpeech/ds/data/smoke_test/vocab.trie ${TASKCLUSTER_TMP_DIR}/trie + cp ${DS_ROOT_TASK}/DeepSpeech/ds/data/smoke_test/vocab.trie.ctcdecode ${TASKCLUSTER_TMP_DIR}/trie } download_material()